A Technical Deep Dive into Adaptive Difficulty in Wavebreaker Chronicles

When designing Wavebreaker Chronicles, I wanted a flexible and scalable system for adaptive difficulty. The core idea was to use normalized values to dynamically adjust enemy stats at runtime. While this approach wasn’t the most memory-efficient, it allowed for easy iteration and balancing. Here’s a detailed look at how it was implemented.

Core Structure: Using ScriptableObjects for Enemy Stats

At the heart of the system was the CharacterStats ScriptableObject. This served as a blueprint for defining the min and max ranges of all relevant stats, ensuring that each type of enemy (ranged, melee, or bosses) could be configured independently.

Here’s a breakdown of the CharacterStats structure:

• Base Stats: These defined the starting values for each stat, such as health, move speed, attack damage, and attack speed.

• Difficulty Ranges: Each stat had a corresponding min and max value, allowing for interpolation based on the normalized difficulty value.

• Normalized Interpolation: At runtime, a normalized difficulty value (between 0 and 1) determined the actual stat values. This made it simple to scale enemy stats dynamically.

Example:

public StatValues GetStatsByNormValue(float normValue)
{
    // Lerp between min and max values using the normalized difficulty value
    newStats.maxHealth = (int)Mathf.Lerp(newStats.DifficultyRanges.minHealth, newStats.DifficultyRanges.maxHealth, normValue);
    newStats.moveSpeed = Mathf.Lerp(newStats.DifficultyRanges.minMoveSpeed, newStats.DifficultyRanges.maxMoveSpeed, normValue);
    newStats.attackDamage = (int)Mathf.Lerp(newStats.DifficultyRanges.minAttackDamage, newStats.DifficultyRanges.maxAttackDamage, normValue);
    newStats.meleeAttackSpeed = Mathf.Lerp(newStats.DifficultyRanges.maxAttackMeleeCooldown, newStats.DifficultyRanges.minAttackMeleeCooldown, normValue);
    // Additional stats omitted for brevity
    return newStats;
}

This design gave us a single, reusable system for dynamically adjusting stats without duplicating code.

---

The Adaptive Procedure

The adaptive procedure was responsible for calculating the normalized difficulty value based on player performance. This value directly influenced the GetStatsByNormValue method, ensuring that the game’s difficulty adjusted in real time.

• Mechanics of Adjustment:

  • Difficulty increased when the player performed well (e.g., achieving 3 kills).

  • Difficulty decreased if the player died, ensuring the game remained accessible.

  • Each Chronicle had a difficulty cap to prevent players from jumping too quickly into the hardest settings.

• Code Implementation: The adaptive procedure tracked key performance metrics and adjusted the normalized value:

void UpdateDifficulty(int kills, bool playerDied)
{
    if (playerDied)
    {
        difficultyNorm = Mathf.Max(0, difficultyNorm - difficultyStep);
    }
    else if (kills % 3 == 0) // Every 3 kills
    {
        difficultyNorm = Mathf.Min(1, difficultyNorm + difficultyStep);
    }
}

The difficultyNorm value was then passed to the GetStatsByNormValue method to update enemy stats dynamically.

---

Enemy Types and Dynamic Behavior

To ensure variety, the system supported three main enemy types: Ranged, Melee, and Bosses. Each enemy type used a different configuration of the CharacterStats ScriptableObject:

1. Ranged Enemies:

   • Prioritized attack range and cooldown adjustments.

   • Configured with larger min and max values for attackRange and rangedAttackSpeed.

2. Melee Enemies:

   • Focused on health and move speed to create close-combat challenges.

   • Interpolated stats like boxDimensions for adjusting attack hitboxes.

3. Bosses:

   • Added unique mechanics by including special abilities and behaviors.

   • Required a higher difficulty cap to challenge experienced players.

     
     

---

Runtime Stat Updates

One of the key decisions was to update stats dynamically at runtime. This approach, while memory-intensive, allowed for easy experimentation and immediate feedback during playtesting.

• How It Worked:

  • Every enemy instance referenced the CharacterStats ScriptableObject.

  • When the normalized value (difficultyNorm) changed, the stats were recalculated, and the enemies updated their attributes.

• Code Example:

void UpdateEnemyStats(EnemyController enemy, float normValue)
{
    CharacterStats.StatValues stats = enemyStats.GetStatsByNormValue(normValue);
    enemy.SetStats(stats);
}

• Why It Wasn’t Memory-Efficient:

  • Updating stats at runtime meant recalculating values for every enemy instance.

  • However, this trade-off was acceptable during development because it simplified balancing and testing.

---

Testing and Iteration

To validate the system, I implemented a wave-based structure with "Chronicles" that recorded player performance:

• Chronicle Structure:

  • Each Chronicle consisted of multiple waves, with increasing difficulty caps.

  • Player performance (kills and deaths) influenced the difficulty for subsequent waves.

• Feedback and Adjustments:

  • Early tests showed that while the difficulty was balanced, the gameplay felt repetitive. This prompted the addition of special abilities and boss fights to inject variety.

  
  

---

Challenges and Improvements

While the system achieved its goal of creating a scalable difficulty model, it also highlighted areas for improvement:

• Static Feel: Because player and enemy stats scaled simultaneously, gameplay often felt stagnant despite the increasing difficulty.

• Memory Use: The runtime updates were taxing, and a more optimized approach (e.g., precomputed difficulty tiers) could have been more efficient.

---

Conclusion

The adaptive difficulty system in Wavebreaker Chronicles demonstrated how normalized values and ScriptableObjects could simplify balancing and scaling. By tying performance metrics to dynamic stat updates, I was able to create a system that adjusted to the player’s skill level in real time.

While the technical approach allowed for quick iteration and testing, the experience highlighted the importance of pairing stat scaling with engaging mechanics and meaningful player choices. For anyone designing similar systems, my advice is to focus not only on balancing difficulty but also on ensuring that progression introduces variety and strategic depth.