Progression Systems

Learning Objectives: By the end of this lesson, you will be able to:

• Design XP curves that create satisfying player growth
• Understand vertical, horizontal, and knowledge-based progression
• Create skill trees with meaningful choices
• Balance progression pacing for different game lengths
• Avoid common progression pitfalls like power creep and dead levels

1. Welcome and Introduction (5 minutes)

Icebreaker Activity

Think about a game where you felt genuinely excited to level up. What made those moments special? Now think of a game where leveling felt like a chore—just grinding numbers. What was different?

Progression is the promise that time invested will be rewarded. When done well, it’s incredibly motivating. When done poorly, it’s exhausting.

Lesson Overview

• Duration: 90-120 minutes
• Prerequisites: Lessons 1-4 (MDA, Loops, Feedback, Combat)
• Materials Needed: Spreadsheet software (Excel/Google Sheets)

2. Learning Objectives and Session Outline (5 minutes)

What We’ll Cover Today:

1. Progression Types - Vertical, horizontal, and knowledge
2. XP and Leveling - Curves and pacing
3. Skill Trees - Meaningful choices and build diversity
4. Unlock Systems - Gates and rewards
5. Avoiding Pitfalls - Power creep, dead levels, overwhelming complexity
6. Case Studies - Learning from successful progression systems

Success Criteria:

By the end of this session, you should be able to design an XP curve and skill tree for any game concept.

3. Foundation Knowledge (15-20 minutes)

Core Concepts

What is Progression?

Progression is any system that makes players more capable over time. It’s the answer to “Why should I keep playing?”

Real-World Analogy: Learning a musical instrument has natural progression. You start with basic scales, gradually learn songs, and eventually master complex pieces. Games formalize this journey with explicit systems.

Why This Matters:

• Progression provides goals and motivation
• It teaches game mechanics gradually
• It creates attachment through investment
• It paces content delivery

Types of Progression

Most games use combinations of all three.

Key Terminology

• XP (Experience Points): Currency that drives level advancement
• Level Curve: How much XP is needed per level
• Power Curve: How player power increases with level
• Skill Tree: Branching choices for ability unlocks
• Talent Point: Currency spent in skill trees
• Soft Cap: Point where progress slows significantly
• Hard Cap: Maximum achievable level/power

4. Detailed Explanation and Examples (25-30 minutes)

Vertical Progression

Vertical progression directly increases player power. Higher level = objectively stronger.

Components of Vertical Progression

1. Stats Growth: HP, Damage, Speed, etc. increase
2. Ability Unlocks: New skills become available
3. Gear Scaling: Better equipment at higher levels
4. Content Access: Higher level areas/challenges unlock

Vertical Progression Pros and Cons

Pros:

• Clear sense of growth
• Numbers going up feels good
• Creates power fantasy
• Natural content gating

Cons:

• Can trivialize old content
• Creates “level requirement” barriers
• Difficult to balance end-game
• Can cause “power creep”

Horizontal Progression

Horizontal progression adds options without directly increasing power.

Examples of Horizontal Progression

• New Classes/Characters: Different playstyles, similar power
• Weapons/Tools: Situationally useful, not strictly better
• Cosmetics: Visual progression without gameplay advantage
• Achievements: Recognition without power

Horizontal Progression Pros and Cons

Pros:

• Old content stays relevant
• Encourages experimentation
• Easier to balance
• Better for multiplayer

Cons:

• Less dramatic sense of growth
• Can feel like “sidegrades”
• May overwhelm with choices
• Harder to communicate value

Knowledge Progression

Knowledge progression happens in the player, not the character.

How Knowledge Progression Works

1. Pattern Recognition: Learning enemy tells and timing
2. System Mastery: Understanding game mechanics deeply
3. Optimization: Finding efficient strategies
4. Muscle Memory: Physical skill improvement

Design for Knowledge Progression

• Clear Tells: Enemies telegraph attacks
• Consistent Rules: Mechanics work the same way everywhere
• Room to Optimize: Depth to discover
• Skill Expression: Ways for mastery to show

XP Curve Design

The XP curve determines how quickly players level up.

Linear XP Curve

XP per level = Base × Level

Level 2: 100 × 2 = 200 XP
Level 5: 100 × 5 = 500 XP
Level 10: 100 × 10 = 1000 XP

Character: Consistent, predictable growth. Each level takes a bit longer.

Exponential XP Curve

XP per level = Base × (Exponent ^ Level)

Level 2: 100 × (1.5 ^ 2) = 225 XP
Level 5: 100 × (1.5 ^ 5) = 760 XP
Level 10: 100 × (1.5 ^ 10) = 5,767 XP

Character: Early levels are fast, later levels are very slow.

Square Root XP Curve (Diminishing)

XP per level = Base × Level^0.5

Level 2: 1000 × 2^0.5 = 1,414 XP
Level 5: 1000 × 5^0.5 = 2,236 XP
Level 10: 1000 × 10^0.5 = 3,162 XP

Character: Slower early game, levels get relatively easier later.

Choosing Your Curve

Skill Trees

Skill trees let players customize their progression path.

Skill Tree Structures

Linear Tree:

[Skill 1] → [Skill 2] → [Skill 3] → [Ultimate]

Simple, clear progression. No real choices.

Branching Tree:

           [Ultimate A]
          ↗
[Start] → [Choice Point]
          ↘
           [Ultimate B]

Clear fork, meaningful choice. Can feel limiting.

Web/Mesh Tree:

[A] ─── [B] ─── [C]
 │   ╲   │   ╱   │
 │    ╲  │  ╱    │
[D] ─── [E] ─── [F]
 │    ╱  │  ╲    │
 │   ╱   │   ╲   │
[G] ─── [H] ─── [I]

Maximum freedom, can be overwhelming. Path of Exile style.

Common Misconceptions

1. Misconception: “More levels = more content” Reality: Empty levels (with no meaningful unlock) feel bad. Quality over quantity.

2. Misconception: “Players want maximum power” Reality: Players want satisfying power. Growing from 100 to 200 damage feels better than 1000 to 1010.

3. Misconception: “Skill trees should be balanced” Reality: Some options can be situational. Not every path needs equal effectiveness in all situations.

5. Live Coding Demonstration (20-25 minutes)

Example 1: Designing an XP Curve

Scenario: Design leveling for a 40-hour RPG, levels 1-50

Step 1: Set Target Pace

total_play_time = 40 * 60  # 2400 minutes
total_levels = 49  # Reaching level 50 from level 1

# Early game: 1 level every 15 minutes (levels 1-10)
# Mid game: 1 level every 45 minutes (levels 11-35)
# Late game: 1 level every 90 minutes (levels 36-50)

early_time = 10 * 15  # 150 minutes
mid_time = 25 * 45    # 1125 minutes
late_time = 15 * 90   # 1350 minutes
total = 150 + 1125 + 1350  # 2625 minutes ≈ 44 hours (close enough)

Step 2: Calculate XP Per Level

def xp_for_level(level):
    if level <= 10:
        return 100 * level  # Easy early game
    elif level <= 35:
        return 500 + (level - 10) * 200  # Steady mid game
    else:
        return 5500 + (level - 35) * 500  # Slow late game

# Test
for level in [1, 5, 10, 20, 35, 45, 50]:
    print(f"Level {level}: {xp_for_level(level)} XP needed")

# Output:
# Level 1: 100 XP needed
# Level 5: 500 XP needed
# Level 10: 1000 XP needed
# Level 20: 2500 XP needed
# Level 35: 5500 XP needed
# Level 45: 10500 XP needed
# Level 50: 13000 XP needed

Step 3: Map to XP Sources

# If monsters give level-appropriate XP
def xp_per_monster(player_level):
    return 10 + player_level * 5  # Scales with player

# At level 10, monsters give: 10 + 50 = 60 XP
# Need 1000 XP for level 11
# = ~17 monsters + quests/bonus XP

# At level 35, monsters give: 10 + 175 = 185 XP
# Need 5500 XP for level 36
# = ~30 monsters + quests/bonus XP

Example 2: Building a Skill Tree

Scenario: Design a mage skill tree with three specializations

Step 1: Define Philosophy

Fire Mage: Burst damage, risky
Ice Mage: Control, defensive
Lightning Mage: Consistent damage, mobility

Step 2: Create Structure

skill_tree = {
    'core': {
        'fireball': {'cost': 1, 'prereq': None, 'effect': 'Basic ranged attack'},
        'frost_bolt': {'cost': 1, 'prereq': None, 'effect': 'Basic slow'},
        'spark': {'cost': 1, 'prereq': None, 'effect': 'Basic chain attack'},
    },
    'fire': {
        'pyroblast': {'cost': 2, 'prereq': 'fireball', 'effect': '+100% fireball damage'},
        'ignite': {'cost': 2, 'prereq': 'pyroblast', 'effect': 'Fire attacks burn'},
        'combustion': {'cost': 3, 'prereq': 'ignite', 'effect': 'Ultimate: Massive AoE'},
    },
    'ice': {
        'blizzard': {'cost': 2, 'prereq': 'frost_bolt', 'effect': 'AoE slow'},
        'freeze': {'cost': 2, 'prereq': 'blizzard', 'effect': 'Slowed enemies freeze'},
        'ice_barrier': {'cost': 3, 'prereq': 'freeze', 'effect': 'Ultimate: Immunity'},
    },
    'lightning': {
        'chain_lightning': {'cost': 2, 'prereq': 'spark', 'effect': 'Hits 3 targets'},
        'static_field': {'cost': 2, 'prereq': 'chain_lightning', 'effect': '%HP damage'},
        'thunderstorm': {'cost': 3, 'prereq': 'static_field', 'effect': 'Ultimate: Teleport + damage'},
    }
}

# Total points available: 1 per level, 50 levels = 50 points
# Core: 3 points (mandatory foundation)
# Specialization: 6 points for one path
# Remaining: 41 points for secondary trees and utility

Step 3: Add Cross-Tree Synergies

hybrid_skills = {
    'frostfire': {
        'cost': 3, 
        'prereq': ['pyroblast', 'blizzard'], 
        'effect': 'Fire attacks apply slow'
    },
    'storm_surge': {
        'cost': 3, 
        'prereq': ['chain_lightning', 'freeze'], 
        'effect': 'Lightning shatters frozen enemies'
    },
    'elemental_mastery': {
        'cost': 5, 
        'prereq': ['combustion', 'ice_barrier', 'thunderstorm'], 
        'effect': 'Reduce all cooldowns by 30%'
    }
}

Example 3: Preventing Dead Levels

Problem: Players hit levels with no meaningful unlock

Analysis:

# Every 5 levels, check what players unlock
level_unlocks = {
    1: "Game start - Tutorial abilities",
    2: "Unlock: Basic skill choice",
    3: "Stat boost only",  # DEAD LEVEL
    4: "Stat boost only",  # DEAD LEVEL
    5: "Unlock: First talent point",
    6: "Stat boost only",  # DEAD LEVEL
    7: "Stat boost only",  # DEAD LEVEL
    8: "Stat boost only",  # DEAD LEVEL
    9: "Stat boost only",  # DEAD LEVEL
    10: "Unlock: New ability",
}
# Problem: Levels 3-4 and 6-9 feel unrewarding

Solution:

improved_unlocks = {
    1: "Tutorial abilities",
    2: "Talent point + new ability slot",
    3: "Gear slot: Helmet",
    4: "Talent point",
    5: "Unlock: Specialty choice",
    6: "New ability",
    7: "Talent point",
    8: "Gear slot: Gloves",
    9: "New ability",
    10: "Milestone reward + Talent point",
}
# Every level has SOMETHING new

Design Principle: Every level should either:

• Unlock a new ability
• Grant meaningful stat boost (big enough to notice)
• Provide a talent/skill point
• Open new content
• Award cosmetic/achievement

6. Hands-On Practice (30-40 minutes)

Exercise 1: XP Curve Design (10 minutes)

Objective: Create a complete XP curve

Scenario: Design leveling for a mobile game with:

• 30 levels total
• 10 hours average playtime
• First 10 levels should take 1 hour total
• Levels 10-20 should take 3 hours
• Levels 20-30 should take 6 hours

Deliverables:

1. XP requirements for all 30 levels
2. XP per common action (killing monster, completing quest)
3. Graph showing cumulative time to reach each level
4. Identify any pacing problems

Template (spreadsheet):

| Level | XP Required | XP from Level 1 | Est. Time to Reach |
|-------|-------------|-----------------|-------------------|
| 1     | 0           | 0               | 0 min             |
| 2     | ???         | ???             | ???               |
...

Exercise 2: Skill Tree Design (15 minutes)

Objective: Create a meaningful skill tree

Scenario: Design skills for a warrior class in an action RPG:

• 20 skill points total (one per level, 20 levels)
• Two specialization paths: Tank (defensive) and Berserker (offensive)
• Players should feel committed to a path but not locked out of the other
• Include 2-3 hybrid options

Deliverables:

1. List of all skills with costs and prerequisites
2. Visual diagram of the tree
3. Example “build” for Tank specialist
4. Example “build” for Berserker specialist
5. Example “hybrid” build

Exercise 3: Progression Audit (15 minutes)

Objective: Analyze and fix a broken progression system

Scenario: A game has these problems:

• Players say levels 15-25 are “the grind”
• Most players quit at level 20
• End-game players say level 50 “doesn’t matter”
• New players feel overwhelmed by skill choices

Requirements:

1. Hypothesize causes for each problem
2. Propose specific fixes for each
3. Explain how your fixes interact
4. Identify any trade-offs in your solutions

7. Common Pitfalls and Troubleshooting (10 minutes)

Frequent Mistakes

1. Problem: Power creep (each expansion makes old content trivial) Cause: Only adding vertical progression Solution: Add horizontal progression, increase level cap slowly

2. Problem: Players skip content to grind optimal path Cause: Uneven XP rewards make some content inefficient Solution: Balance XP rates across content types

3. Problem: Skill tree has “trap” options that seem good but aren’t Cause: Poor internal testing, options that don’t scale Solution: Test all builds, ensure situational value

4. Problem: Returning players feel lost Cause: Too much new content/complexity since they left Solution: “Catch-up” mechanics, clear returning player experience

Debugging Tips

• Track player drop-off: At what level do players quit?
• Monitor build diversity: Are players all using the same skills?
• Watch new player experience: Where do they get stuck?
• Survey veterans: What feels unrewarding?

Warning Signs

8. Best Practices and Professional Tips (5 minutes)

Industry Standards

• First hour: Players should level 3-5 times minimum
• Skill points: Award frequently (every level or every other)
• Respec: Always allow players to redo choices (maybe with cost)
• Visual feedback: Make level-ups feel celebratory

Advanced Techniques

Prestige Systems: Reset progress for permanent bonuses:

Prestige 0: Level 1-50
Prestige 1: Level 1-50 (+10% XP gain)
Prestige 2: Level 1-50 (+20% XP gain, new cosmetics)

Paragon/Infinite Leveling: Post-cap progression that continues forever:

Level 50: Cap
Paragon 1: +1% damage
Paragon 2: +1% health
... continues indefinitely

Seasonal Resets: Periodic fresh starts keep progression meaningful:

Season 1: Everyone starts at level 1
Season ends: Transfer rewards to permanent account
Season 2: Everyone starts at level 1 again

Next Steps in Your Learning Journey

• Study how MMOs handle expansion power creep
• Analyze skill tree diversity in Path of Exile
• Research mobile game progression monetization
• Prototype a progression system in a game engine

9. Summary and Review (5 minutes)

Key Takeaways

1. Three types of progression - Vertical (power), Horizontal (options), Knowledge (skill)
2. XP curves shape pacing - Choose based on your game’s goals
3. Skill trees need meaningful choices - Avoid traps and must-picks
4. Every level should reward something - No dead levels
5. Horizontal progression helps longevity - Sidegrades keep content relevant

Quick Review Questions

1. What’s the difference between vertical and horizontal progression?
2. What’s a “dead level” and how do you prevent them?
3. When would you use an exponential vs linear XP curve?
4. How do you ensure skill tree choices are meaningful?

For Instructors

Teaching Tips

• Use spreadsheets live to show XP curve effects
• Compare progression in games students know
• Have students design skill trees on whiteboards
• Discuss the psychology of “numbers going up”

Assessment Ideas

• Complete XP curve design with spreadsheet analysis
• Skill tree design document with rationale
• Audit of an existing game’s progression system
• Presentation on a game’s handling of post-cap content

Adaptation Notes

• For beginners: Focus on basic XP curves and simple skill trees
• For advanced students: Discuss prestige systems, seasonal models
• For mobile focus: Emphasize monetization integration
• For RPG focus: Deep dive into stat systems and build diversity