Economy Systems

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

• Design balanced game economies with multiple currency types
• Calculate and manage sources (faucets) and sinks (drains)
• Prevent inflation and deflation in virtual economies
• Create ethical monetization that respects players
• Model economies in spreadsheets before implementation

1. Welcome and Introduction (5 minutes)

Icebreaker Activity

Have you ever played a game where gold became meaningless late-game? Or one where you could never afford anything you wanted? Both are symptoms of economic design failures. Think about games where the economy felt “just right” - what made the difference?

Economy systems are often invisible when working well, but painfully obvious when broken.

Lesson Overview

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

2. Learning Objectives and Session Outline (5 minutes)

What We’ll Cover Today:

1. Economic Fundamentals - Resources, currencies, and value
2. Sources and Sinks - Where resources come from and go
3. Balance Equations - Preventing inflation and deflation
4. Monetization Design - Free-to-play economics and ethics
5. Modeling Techniques - Spreadsheet-based economy design
6. Case Studies - Learning from real game economies

Success Criteria:

By the end of this session, you should be able to model a game economy in a spreadsheet and identify potential balance issues.

3. Foundation Knowledge (15-20 minutes)

Core Concepts

What is a Game Economy?

A game economy is the system that governs how resources flow through your game. It includes:

• What resources exist
• How players acquire them
• How players spend them
• How resources affect gameplay

Real-World Analogy: A game economy is like a bathtub. The faucet pours water in (sources), the drain lets water out (sinks). If the faucet runs faster than the drain, the tub overflows (inflation). If the drain is faster, the tub empties (deflation). Balance means the water level stays appropriate.

Why This Matters:

• Economy affects every aspect of player experience
• Poor economies cause frustration or trivialization
• Good economies provide goals and motivation
• Monetization depends on healthy economic design

Key Terminology

• Currency: A resource used as medium of exchange
• Hard Currency: Premium, usually purchased with real money
• Soft Currency: Standard, earned through gameplay
• Source/Faucet: Where currency enters the economy
• Sink/Drain: Where currency leaves the economy
• Inflation: Currency becoming less valuable over time
• Deflation: Currency becoming more valuable (scarce)
• Purchasing Power: What a unit of currency can buy

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

Currency Types

Soft Currency

Earned primarily through gameplay.

Characteristics:

• Unlimited earning potential
• Used for common purchases
• Usually single type per game
• Examples: Gold, Coins, Credits

Design Considerations:

• Must have enough sinks to maintain value
• Should be earnable at satisfying rate
• Players should always have something to spend it on

Hard Currency

Scarce premium currency, often purchasable.

Characteristics:

• Limited earning (or none) through gameplay
• Used for premium/convenience purchases
• Creates monetization opportunity
• Examples: Gems, Crystals, Premium Credits

Design Considerations:

• Must feel valuable (scarcity)
• Purchases should feel fair, not required
• Should respect player investment
• Never pay-to-win if possible

Energy/Stamina

Time-gated resource that regenerates.

Characteristics:

• Limits play sessions
• Regenerates over real time
• Can often be purchased/refilled
• Examples: Stamina, Lives, Action Points

Design Considerations:

• Controversial but effective for retention
• Must not feel punishing
• Regeneration rate affects session frequency
• Premium currency bypass must feel optional

Materials/Ingredients

Specific resources for crafting/upgrading.

Characteristics:

• Multiple types with different sources
• Targeted grind for specific goals
• Creates scavenger hunt gameplay
• Examples: Ore, Wood, Monster Drops

Design Considerations:

• Inventory management complexity
• Drop rates affect grind feel
• Trading systems add social economy

Sources and Sinks

Common Sources (Faucets)

Common Sinks (Drains)

Balance Equations

The fundamental equation:

Total Sources - Total Sinks = Net Currency Flow

If Net Flow > 0: Inflation (more currency in economy)
If Net Flow < 0: Deflation (less currency in economy)
If Net Flow ≈ 0: Stable economy

Calculating Balance

Example: Mobile RPG Daily Economy

# Daily sources per active player
daily_sources = {
    'quest_rewards': 500,
    'monster_drops': 300,  # 30 monsters × 10 gold each
    'daily_login': 100,
    'achievements': 50,    # Average across players
}
total_daily_source = 950  # gold per day

# Daily sinks per active player
daily_sinks = {
    'equipment_average': 200,
    'consumables': 150,
    'upgrades': 100,
}
total_daily_sink = 450  # gold per day

# Net flow
net_daily = 950 - 450  # = +500 gold per day

# Problem: Economy inflates by 500 gold/day/player
# After 30 days: 15,000 gold accumulated
# Players will have nothing to spend it on!

Solution: Add More Sinks

additional_sinks = {
    'gear_enhancement': 300,    # New system
    'guild_donations': 100,     # Social sink
    'cosmetic_shop': 50,        # Optional spending
}
new_total_sink = 450 + 450  # = 900 gold per day

new_net_daily = 950 - 900  # = +50 gold per day
# Slight inflation for player satisfaction, but controlled

Common Misconceptions

1. Misconception: “More currencies = more depth” Reality: Multiple currencies add complexity. Only add if each serves a purpose.

2. Misconception: “Inflation is always bad” Reality: Slight inflation feels good (accumulation). Zero or negative feels punishing.

3. Misconception: “Players hate spending” Reality: Players love MEANINGFUL spending. They hate wasted spending.

5. Live Coding Demonstration (20-25 minutes)

Example 1: Building an Economy Model

Scenario: Model economy for a 30-day mobile game event

# Player economy model
class PlayerEconomy:
    def __init__(self):
        self.gold = 0
        self.gems = 0
        self.stamina = 100
        self.max_stamina = 100
        self.day = 0
        
    def daily_sources(self):
        """Calculate daily currency income"""
        # Base gameplay (depends on stamina spent)
        battles = self.stamina // 10  # 10 stamina per battle
        gold_from_battles = battles * 15  # 15 gold per battle
        
        # Fixed daily
        daily_login = 50
        daily_quest = 100
        
        return {
            'gold': gold_from_battles + daily_login + daily_quest,
            'gems': 5  # Small trickle from ads/achievements
        }
    
    def daily_sinks(self, spending_level='normal'):
        """Calculate daily currency spending"""
        if spending_level == 'aggressive':
            return {'gold': 200, 'gems': 0}
        elif spending_level == 'normal':
            return {'gold': 100, 'gems': 0}
        else:  # minimal
            return {'gold': 50, 'gems': 0}
    
    def simulate_day(self, spending='normal'):
        sources = self.daily_sources()
        sinks = self.daily_sinks(spending)
        
        self.gold += sources['gold'] - sinks['gold']
        self.gems += sources['gems'] - sinks['gems']
        self.stamina = self.max_stamina  # Refill overnight
        self.day += 1
        
        return {
            'day': self.day,
            'gold': self.gold,
            'gems': self.gems,
            'net_gold': sources['gold'] - sinks['gold']
        }

# Simulate 30 days
player = PlayerEconomy()
results = []
for _ in range(30):
    results.append(player.simulate_day())

# Print summary
print(f"Day 1: {results[0]['gold']} gold")
print(f"Day 15: {results[14]['gold']} gold")
print(f"Day 30: {results[29]['gold']} gold")
print(f"Average daily net: {sum(r['net_gold'] for r in results)/30:.0f} gold")

Example 2: Gacha Economy Design

Scenario: Design a character gacha system

import random

class GachaSystem:
    def __init__(self):
        self.pity_counter = 0
        self.pity_threshold = 90  # Guaranteed at 90 pulls
        
        # Pull costs
        self.cost_per_pull = 160  # gems
        self.multi_pull_cost = 1600  # 10 pulls for price of 10
        
        # Drop rates
        self.rates = {
            'common': 0.60,
            'uncommon': 0.25,
            'rare': 0.10,
            'legendary': 0.03,
            'mythic': 0.02
        }
        
    def pull(self):
        """Single pull with pity system"""
        self.pity_counter += 1
        
        # Hard pity
        if self.pity_counter >= self.pity_threshold:
            self.pity_counter = 0
            return 'mythic'  # Guaranteed
        
        # Soft pity (increasing rates after 75 pulls)
        mythic_rate = self.rates['mythic']
        if self.pity_counter > 75:
            mythic_rate += (self.pity_counter - 75) * 0.02
        
        roll = random.random()
        cumulative = 0
        for rarity, rate in self.rates.items():
            if rarity == 'mythic':
                rate = mythic_rate
            cumulative += rate
            if roll < cumulative:
                if rarity == 'mythic':
                    self.pity_counter = 0
                return rarity
        
        return 'common'
    
    def simulate_player(self, gem_budget):
        """Simulate spending a gem budget"""
        pulls = gem_budget // self.cost_per_pull
        results = {'common': 0, 'uncommon': 0, 'rare': 0, 
                   'legendary': 0, 'mythic': 0}
        
        for _ in range(pulls):
            result = self.pull()
            results[result] += 1
            
        return {
            'pulls': pulls,
            'gems_spent': pulls * self.cost_per_pull,
            'results': results
        }

# Simulate different spending levels
gacha = GachaSystem()

# F2P player: ~30 pulls/month from free gems
f2p = gacha.simulate_player(gem_budget=4800)
print(f"F2P (30 pulls): {f2p['results']}")

# Light spender: ~50 pulls/month
gacha = GachaSystem()  # Reset pity
light = gacha.simulate_player(gem_budget=8000)
print(f"Light spender (50 pulls): {light['results']}")

# Whale: 180 pulls (2 pity cycles guaranteed)
gacha = GachaSystem()  # Reset pity
whale = gacha.simulate_player(gem_budget=28800)
print(f"Whale (180 pulls): {whale['results']}")

Example 3: Inflation Prevention

Problem: Veteran players have millions of gold, nothing to spend it on

# Anti-inflation sink design
class VeteranEconomySink:
    """High-cost optional content for veterans"""
    
    def __init__(self):
        self.sinks = {
            # One-time prestige items
            'golden_mount': {'cost': 1000000, 'type': 'cosmetic'},
            'legacy_title': {'cost': 500000, 'type': 'prestige'},
            
            # Repeatable investments
            'guild_upgrade': {'cost': 100000, 'type': 'social', 'repeatable': True},
            'research_points': {'cost': 50000, 'type': 'progression', 'repeatable': True},
            
            # Competitive sinks
            'season_pass_premium': {'cost': 200000, 'type': 'season'},
            'tournament_entry': {'cost': 10000, 'type': 'competitive'},
            
            # Altruistic sinks
            'newbie_gift_fund': {'cost': 25000, 'type': 'charity'},
            'server_event_donation': {'cost': 50000, 'type': 'community'},
        }
    
    def calculate_sink_potential(self, active_veterans, avg_gold):
        """Estimate how much gold these sinks can absorb"""
        total_sinkable = 0
        
        for sink_name, sink_data in self.sinks.items():
            if sink_data.get('repeatable'):
                # Assume veterans use repeatable sinks 10x/month
                total_sinkable += sink_data['cost'] * 10 * active_veterans
            else:
                # One-time sinks, assume 30% adoption
                total_sinkable += sink_data['cost'] * active_veterans * 0.3
        
        return {
            'monthly_sink_capacity': total_sinkable,
            'per_veteran_capacity': total_sinkable / active_veterans,
            'months_to_drain': (avg_gold * active_veterans) / total_sinkable
        }

# Analysis
sink_system = VeteranEconomySink()
result = sink_system.calculate_sink_potential(
    active_veterans=1000, 
    avg_gold=5000000
)
print(f"Monthly sink capacity: {result['monthly_sink_capacity']:,.0f} gold")
print(f"Per veteran: {result['per_veteran_capacity']:,.0f} gold/month")
print(f"Time to healthy economy: {result['months_to_drain']:.1f} months")

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

Exercise 1: Economy Balance Sheet (10 minutes)

Objective: Create a balanced economy model

Scenario: Design economy for a city-building mobile game:

• Session length: 15-20 minutes
• Retention goal: Daily play for 30+ days
• Monetization: Optional cosmetics and time-savers

Deliverables (spreadsheet):

| Source | Gold/Day | Notes |
|--------|----------|-------|
| Building income | ??? | Main passive |
| Quest completion | ??? | Active play |
| Daily bonus | ??? | Retention |
| Total Sources | ??? | |

| Sink | Gold/Day | Notes |
|------|----------|-------|
| New buildings | ??? | Main spending |
| Upgrades | ??? | Progress |
| Decorations | ??? | Optional |
| Total Sinks | ??? | |

Net Daily Flow: ???
30-Day Accumulation: ???

Exercise 2: Monetization Design (15 minutes)

Objective: Create ethical free-to-play monetization

Scenario: Design monetization for a competitive puzzle game:

• Free to download
• Optional purchases only
• Must feel fair to non-payers
• Target: $0.50 ARPDAU (Average Revenue Per Daily Active User)

Requirements:

1. List 5 things players can purchase
2. Price each item (in USD or premium currency)
3. Explain why each feels fair
4. Identify what CANNOT be purchased (to maintain fairness)
5. Calculate expected revenue if 5% of players spend $10/month

Exercise 3: Inflation Diagnosis (15 minutes)

Objective: Find and fix economy problems

Scenario: An MMO has these symptoms:

• New players struggle to afford basic gear
• Veterans have billions of gold
• Prices on player auction house increasing weekly
• Players complain economy is “broken”

Requirements:

1. Identify the type of problem (inflation/deflation)
2. List 3 likely causes
3. Propose 3 sinks to address veteran wealth
4. Propose 2 sources to help new players
5. Explain how to implement without angering either group

7. Common Pitfalls and Troubleshooting (10 minutes)

Frequent Mistakes

1. Problem: Currency becomes worthless late-game Cause: Insufficient sinks, sources scale with player power Solution: Add scaling sinks, prestige systems, consumable demand

2. Problem: New players can never catch up Cause: Fixed costs with veteran-level pricing Solution: Level-appropriate content, catch-up bonuses

3. Problem: Pay-to-win backlash Cause: Monetizing power directly Solution: Sell convenience and cosmetics, not stats

4. Problem: Trading economy exploited Cause: Predictable arbitrage opportunities Solution: Trading fees, item binding, fluctuating prices

Debugging Tips

• Track currency over time: Graph accumulation curves
• Segment by player type: New vs. veteran economies differ
• Monitor prices: Player-set prices reveal economic health
• Survey frustration: What can’t players afford?

Warning Signs

8. Best Practices and Professional Tips (5 minutes)

Industry Standards

• Soft currency: 60-70% of purchases
• Hard currency: Slow F2P earning (5-10% of content accessible)
• First purchase discount: 50-80% off to convert
• Daily purchase limit: Prevents regret, reduces refunds

Ethical Monetization Guidelines

Do:

• Sell time savings, not power
• Offer meaningful free play
• Be transparent about odds
• Provide value at multiple price points
• Allow earning of premium currency (slowly)

Don’t:

• Gate essential content behind paywall
• Create artificial frustration
• Target vulnerable players
• Hide odds or mechanics
• Make purchases mandatory for progress

Next Steps in Your Learning Journey

• Study real game economies (MMOs are great examples)
• Read game postmortems about economic failures
• Experiment with economy simulation tools
• Follow mobile game monetization discussions

9. Summary and Review (5 minutes)

Key Takeaways

1. Economies need balance between sources and sinks
2. Multiple currencies serve different purposes
3. Inflation/deflation both cause problems
4. Ethical monetization respects players and still generates revenue
5. Spreadsheet modeling catches problems before launch

Quick Review Questions

1. What’s the difference between soft and hard currency?
2. How do you prevent inflation in a game economy?
3. Name three ethical monetization strategies.
4. Why might veteran players having too much gold be a problem?

For Instructors

Teaching Tips

• Use real game examples (Eve Online, Fortnite, etc.)
• Have students compare F2P games’ monetization
• Build spreadsheet models together
• Discuss ethics of loot boxes openly

Assessment Ideas

• Complete economy balance sheet for a game concept
• Monetization design document with ethical analysis
• Case study of a failed game economy
• Presentation comparing two games’ economic approaches

Adaptation Notes

• For beginners: Focus on basic source/sink balance
• For advanced students: Discuss real-money trading, complex economies
• For mobile focus: Emphasize retention and monetization integration
• For ethics focus: Deep dive into manipulation concerns