Emergent Gameplay

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

• Design systems that interact to create unexpected gameplay
• Balance between authored content and emergent possibilities
• Create tools for player expression and creativity
• Recognize emergence in existing games and understand why it works
• Avoid common pitfalls that prevent or break emergence

1. Welcome and Introduction (5 minutes)

Icebreaker Activity

Have you ever solved a game problem in a way the developers clearly didn’t intend? Used a physics object as a weapon? Combined abilities in unexpected ways? Found a shortcut the level designer didn’t plan?

Those moments—where you surprised the game—are emergent gameplay. They’re often the most memorable moments in gaming.

Lesson Overview

• Duration: 90-120 minutes
• Prerequisites: Lessons 1-7 (All foundations and core systems)
• Materials Needed: Access to games with strong emergence (BotW, Minecraft, etc.)

2. Learning Objectives and Session Outline (5 minutes)

What We’ll Cover Today:

1. What is Emergence? - Definition and examples
2. Designing for Emergence - Systemic interactions
3. Player Expression - Tools for creativity
4. Sandbox Design - Spaces for experimentation
5. Balancing Emergence - Preventing exploits while enabling discovery
6. Case Studies - Learning from masters of emergence

Success Criteria:

By the end of this session, you should be able to design interconnected systems that produce emergent gameplay possibilities.

3. Foundation Knowledge (15-20 minutes)

Core Concepts

What is Emergent Gameplay?

Emergent gameplay occurs when simple rules combine to create complex behaviors that designers didn’t explicitly program.

Formula:

Simple Rules + Player Creativity = Unexpected Outcomes

Real-World Analogy: Chess has only 6 piece types and simple movement rules. Yet from these simple rules emerge countless strategies, openings, and famous games. No one programmed “The Queen’s Gambit” into chess—it emerged from players exploring the possibility space.

Why This Matters:

• Emergence creates memorable, unique experiences
• Players feel like discoverers, not followers
• Content multiplies beyond what designers create
• Replayability increases dramatically

Types of Emergence

Key Terminology

• Systemic Design: Creating interconnected systems rather than scripted events
• Possibility Space: All possible states and outcomes in a game
• Orthogonal Mechanics: Mechanics that can combine in multiple ways
• Emergent Narrative: Stories that arise from gameplay, not scripts
• Sandbox: Open environment for player experimentation

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

Designing for Emergence

Principle 1: Systemic Interactions

Instead of designing specific solutions, design systems that can affect each other.

Non-Systemic (Scripted):

IF player has fire arrow AND enemy is ice boss:
    enemy takes extra damage

Systemic:

Fire element:
  - Melts ice
  - Ignites flammable objects
  - Heats metal
  - Creates updrafts
  - Hurts ice creatures

Ice element:
  - Freezes water
  - Slows creatures
  - Shatters when hit hard
  - Puts out fires

Now fire and ice interact with EVERYTHING that shares those properties, not just specific cases.

Principle 2: Consistent Rules

Systems must behave consistently for players to learn and experiment.

Breath of the Wild’s Metal Rule:

• Metal conducts electricity
• This works for: player weapons, enemy weapons, treasure chests, metal boxes, ore deposits, rails…
• Players learn the rule once, apply it everywhere

Breaking Consistency Breaks Trust:

Player: "Metal conducts electricity"
Game: "Yes, except this specific metal door"
Player: "...I can't trust anything"

Principle 3: Player Tools

Give players versatile tools, not single-purpose solutions.

Single-Purpose Tool:

Fire Arrow: Does fire damage to enemies

Versatile Tool:

Fire:
- Ignites enemies (damage over time)
- Burns wooden objects (remove obstacles)
- Cooks food (nutrition bonus)
- Lights torches (solve puzzles)
- Creates updrafts (vertical mobility)
- Spreads across surfaces (area denial)

Principle 4: AI as Participant

NPCs and enemies should use the same systems as players.

Breath of the Wild:

• Enemies drop weapons when shocked
• Enemies can pick up player’s dropped weapons
• Enemies use the same physics as players
• Enemies are affected by weather

This creates:

• Fair play (same rules apply)
• Unexpected moments (enemy uses my weapon against me!)
• Strategic depth (deny enemies good weapons)

Designing Interaction Matrices

Map out how systems can interact:

             | Fire | Water | Electricity | Physics | AI
-------------|------|-------|-------------|---------|----
Fire         | -    | Steam | -           | Updraft | Flee/Attack
Water        | Out  | -     | Conducts    | Flow    | Swim/Drown
Electricity  | -    | Spread| -           | -       | Stun
Physics      | -    | Splash| -           | Chain   | Ragdoll
AI           | -    | Seek  | Avoid       | Use     | Social

Each intersection is an opportunity for emergence.

Common Misconceptions

1. Misconception: “Emergence means no rules” Reality: Emergence requires consistent, predictable rules. Chaos isn’t emergence.

2. Misconception: “We can’t design emergence, it just happens” Reality: Emergence is absolutely designable through systemic thinking.

3. Misconception: “Emergence makes design easier” Reality: Systemic design is harder—you must consider all interactions.

5. Live Coding Demonstration (20-25 minutes)

Example 1: Elemental Interaction System

class ElementalSystem:
    def __init__(self):
        # Define base interactions
        self.interactions = {
            ('fire', 'water'): ['steam', 'extinguish'],
            ('fire', 'grass'): ['spread_fire', 'burn'],
            ('fire', 'ice'): ['melt', 'water'],
            ('fire', 'wood'): ['ignite', 'burn'],
            ('fire', 'metal'): ['heat', 'conducts'],
            
            ('water', 'electricity'): ['electrify_area', 'conduct'],
            ('water', 'fire'): ['extinguish', 'steam'],
            ('water', 'ice'): ['freeze', 'expand'],
            
            ('electricity', 'metal'): ['conduct', 'chain'],
            ('electricity', 'water'): ['spread', 'stun_area'],
            
            ('wind', 'fire'): ['spread', 'fan_flames'],
            ('wind', 'water'): ['spray', 'waves'],
        }
        
    def get_interaction(self, elem1, elem2):
        # Check both orderings
        key = (elem1, elem2)
        if key in self.interactions:
            return self.interactions[key]
        
        key = (elem2, elem1)
        if key in self.interactions:
            return self.interactions[key]
        
        return ['no_interaction']
    
    def simulate_event(self, element, target_properties):
        """
        Simulate what happens when element affects an object with properties
        """
        results = []
        
        for prop in target_properties:
            interaction = self.get_interaction(element, prop)
            if interaction != ['no_interaction']:
                results.append({
                    'property': prop,
                    'effects': interaction
                })
        
        return results

# Test emergent interactions
system = ElementalSystem()

# Scenario: Fire arrow hits enemy carrying metal sword standing in water
enemy_properties = ['organic', 'metal', 'in_water']
fire_effects = system.simulate_event('fire', enemy_properties)
print("Fire arrow effects:", fire_effects)

# Scenario: Lightning spell in rainy area with multiple enemies
area_properties = ['water', 'metal', 'organic']
lightning_effects = system.simulate_event('electricity', area_properties)
print("Lightning effects:", lightning_effects)

# The emergence: Players discover lightning + rain = area damage
# We didn't script "lightning rain combo", it emerges from rules

Example 2: Physics-Based Puzzle Emergence

import random

class PhysicsObject:
    def __init__(self, obj_type, position, properties):
        self.type = obj_type
        self.position = position
        self.properties = set(properties)
        self.velocity = [0, 0]
        self.state = 'normal'
    
    def apply_force(self, direction, magnitude):
        if 'moveable' in self.properties:
            self.velocity[0] += direction[0] * magnitude
            self.velocity[1] += direction[1] * magnitude
    
    def update(self, world):
        # Apply velocity
        self.position[0] += self.velocity[0]
        self.position[1] += self.velocity[1]
        
        # Friction
        self.velocity[0] *= 0.9
        self.velocity[1] *= 0.9

class EmergentWorld:
    def __init__(self):
        self.objects = []
        self.elements_at_position = {}
    
    def add_object(self, obj):
        self.objects.append(obj)
    
    def apply_element_to_area(self, element, position, radius):
        """Apply an element to an area, let emergence happen"""
        affected = []
        
        for obj in self.objects:
            dist = abs(obj.position[0] - position[0]) + abs(obj.position[1] - position[1])
            if dist <= radius:
                effects = self.resolve_element_object(element, obj)
                affected.append((obj, effects))
        
        return affected
    
    def resolve_element_object(self, element, obj):
        effects = []
        
        if element == 'fire':
            if 'flammable' in obj.properties:
                obj.state = 'burning'
                effects.append('ignited')
            if 'ice' in obj.properties:
                obj.properties.remove('ice')
                obj.properties.add('wet')
                effects.append('melted')
            if 'metal' in obj.properties:
                obj.properties.add('hot')
                effects.append('heated')
        
        elif element == 'electricity':
            if 'metal' in obj.properties or 'wet' in obj.properties:
                obj.state = 'shocked'
                effects.append('electrified')
                # Chain to nearby metal/wet objects!
                effects.append('chain_potential')
        
        elif element == 'wind':
            if 'light' in obj.properties:
                obj.apply_force([1, 0], 5)
                effects.append('pushed')
            if obj.state == 'burning':
                effects.append('fire_spread')
        
        return effects

# Create a scenario
world = EmergentWorld()

# Add objects with various properties
world.add_object(PhysicsObject('crate', [5, 5], ['moveable', 'flammable', 'light']))
world.add_object(PhysicsObject('metal_box', [6, 5], ['moveable', 'metal']))
world.add_object(PhysicsObject('puddle', [7, 5], ['wet']))
world.add_object(PhysicsObject('enemy', [7, 6], ['wet', 'organic']))

# Emergent scenario: Lightning hits the metal box
print("Lightning strikes metal_box:")
results = world.apply_element_to_area('electricity', [6, 5], 2)
for obj, effects in results:
    print(f"  {obj.type}: {effects}")

# The emergence: Lightning chains through wet enemy via puddle!
# We didn't script "lightning chain attack", physics did it

Example 3: Emergent AI Behavior

class EmergentAI:
    """AI that reacts to systemic world state, not scripts"""
    
    def __init__(self, ai_type):
        self.type = ai_type
        self.state = 'idle'
        self.fear_threshold = 0.5
        self.aggression = 0.5
        
        # What this AI cares about
        self.fears = {'fire': 0.8, 'electricity': 0.6}
        self.desires = {'food': 0.7, 'weapon': 0.5}
        self.hostility_to = {'player': 0.9}
    
    def perceive_world(self, world_state):
        """React to world conditions"""
        actions = []
        
        # Fear responses
        for threat, fear_level in self.fears.items():
            if threat in world_state.get('nearby_elements', []):
                if fear_level > self.fear_threshold:
                    actions.append(('flee_from', threat))
        
        # Desire responses
        for desire, desire_level in self.desires.items():
            if desire in world_state.get('nearby_objects', []):
                actions.append(('approach', desire))
        
        # Combat responses
        if 'player' in world_state.get('visible_entities', []):
            if 'weapon' in world_state.get('held_item', []):
                actions.append(('attack', 'player'))
            else:
                actions.append(('search', 'weapon'))
        
        return self.prioritize_actions(actions)
    
    def prioritize_actions(self, actions):
        # Fear overrides everything
        flee_actions = [a for a in actions if a[0] == 'flee_from']
        if flee_actions:
            return flee_actions[0]
        
        # Then combat
        attack_actions = [a for a in actions if a[0] == 'attack']
        if attack_actions:
            return attack_actions[0]
        
        # Then desires
        if actions:
            return actions[0]
        
        return ('idle', None)

# Emergent scenario
enemy = EmergentAI('goblin')

# Scenario 1: Normal combat
world = {
    'visible_entities': ['player'],
    'held_item': ['club'],
    'nearby_elements': [],
    'nearby_objects': []
}
action = enemy.perceive_world(world)
print(f"Normal combat: {action}")  # ('attack', 'player')

# Scenario 2: Player sets fire nearby
world['nearby_elements'] = ['fire']
action = enemy.perceive_world(world)
print(f"Fire nearby: {action}")  # ('flee_from', 'fire')

# Emergence: Player can use fire to make enemies drop weapons and flee!
# We didn't script "enemies fear fire", they fear fire because fire hurts

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

Exercise 1: Interaction Matrix (10 minutes)

Objective: Design systemic interactions

Instructions:

1. Choose 5 elements/properties for a game (e.g., fire, water, metal, wood, electricity)
2. Create a 5x5 interaction matrix
3. For each intersection, define 1-2 emergent effects
4. Identify the most interesting combinations

Template:

         | Elem A | Elem B | Elem C | Elem D | Elem E |
---------|--------|--------|--------|--------|--------|
Elem A   |   -    |        |        |        |        |
Elem B   |        |   -    |        |        |        |
Elem C   |        |        |   -    |        |        |
Elem D   |        |        |        |   -    |        |
Elem E   |        |        |        |        |   -    |

Exercise 2: Emergent Puzzle Design (15 minutes)

Objective: Create a puzzle with multiple solutions

Scenario: Design a puzzle room where players must cross a gap. Provide:

• 3 different object types players can use
• 3 different element interactions available
• At least 5 different ways to solve the puzzle

Requirements:

1. Define the room layout
2. List all objects and their properties
3. Document at least 5 solutions
4. Identify which solutions are “intended” vs “emergent”

Exercise 3: Break the Game (15 minutes)

Objective: Find emergence in existing games

Instructions: Choose a systemic game (BotW, Minecraft, Immersive Sim, etc.) and:

1. Identify 3 emergent strategies the designers probably intended
2. Identify 2 emergent strategies that seem unintended
3. Find 1 example where emergence breaks the intended challenge
4. Propose how to preserve the emergence while fixing the break

7. Common Pitfalls and Troubleshooting (10 minutes)

Frequent Mistakes

1. Problem: Emergence breaks intended difficulty Cause: Systems interact to trivialize challenges Solution: Playtest for degenerate strategies, add soft counters

2. Problem: Players don’t discover emergence Cause: Systems are too subtle or complex Solution: Tutorial hints, consistent feedback, observable AI using systems

3. Problem: Emergence causes bugs/crashes Cause: Unanticipated system interactions Solution: Extensive interaction testing, fail-safe states

4. Problem: “Best” strategy emerges, killing variety Cause: One emergence is too powerful Solution: Situational counters, resource costs, cooldowns

Warning Signs

8. Best Practices and Professional Tips (5 minutes)

Industry Standards

• Immersive Sims: ~20-30 key interacting systems
• Sandbox Games: Physics + building + AI minimum
• Testing: 10x more for systemic games
• Documentation: Interaction matrices are essential

Design Philosophy

The Miyamoto Approach: “Design one good mechanic, then find 100 uses for it.”

The Arkane Approach: “Give players tools, not solutions. Trust them to surprise you.”

The Valve Approach: “If players can break it in playtesting, they will break it in release. Decide if that’s fun.”

9. Summary and Review (5 minutes)

Key Takeaways

1. Emergence = Simple rules + Interactions + Player creativity
2. Consistency is crucial - players must trust the rules
3. Design interactions, not solutions - let players discover
4. Test extensively - emergence can break in unexpected ways
5. Embrace the unexpected - sometimes bugs become features

Quick Review Questions

1. What’s the difference between scripted and systemic design?
2. Why is consistency important for emergence?
3. How do you prevent dominant emergent strategies?
4. What makes a tool “versatile” vs “single-purpose”?

For Instructors

Teaching Tips

• Play emergent games together and discuss what’s happening
• Challenge students to solve problems in unexpected ways
• Share famous emergent moments (rocket jumping, skiing, etc.)
• Discuss when emergence should be patched vs celebrated

Assessment Ideas

• Interaction matrix for a game concept
• Analysis of emergence in an existing game
• Design document for an emergent puzzle
• Playtest report identifying emergent behaviors

Adaptation Notes

• For beginners: Focus on simple element interactions
• For advanced: Discuss computational complexity of testing emergence
• For programmers: Implement interaction systems
• For level designers: Create spaces that encourage experimentation