Game Narrative Design — Storytelling in Games Guide

import json

class DialogueNode:
    def __init__(self, node_id, speaker, text, 
                 choices=None, conditions=None, effects=None):
        self.id = node_id
        self.speaker = speaker
        self.text = text
        self.choices = choices or []  # List of (text, target_node_id)
        self.conditions = conditions or {}  # Required flags
        self.effects = effects or {}  # Flags to set when visited
    
    def is_available(self, game_state):
        """Check if this dialogue is available based on game state."""
        for flag, value in self.conditions.items():
            if game_state.get(flag) != value:
                return False
        return True
    
    def apply_effects(self, game_state):
        """Apply narrative effects when this node is visited."""
        game_state.update(self.effects)

class DialogueSystem:
    def __init__(self):
        self.nodes = {}
        self.current_node = None
        self.history = []
    
    def add_node(self, node):
        self.nodes[node.id] = node
    
    def load_from_json(self, filename):
        with open(filename, 'r') as f:
            data = json.load(f)
            for node_data in data['nodes']:
                self.add_node(DialogueNode(**node_data))
    
    def start_dialogue(self, node_id, game_state):
        self.current_node = self.nodes[node_id]
        if not self.current_node.is_available(game_state):
            return None  # Skip unavailable dialogue
        return self.get_current_text(game_state)
    
    def get_current_text(self, game_state):
        node = self.current_node
        if not node:
            return None
        
        # Apply effects
        node.apply_effects(game_state)
        self.history.append(node.id)
        
        return {
            'speaker': node.speaker,
            'text': node.text,
            'choices': [
                (text, target) 
                for text, target in node.choices
                if self.nodes[target].is_available(game_state)
            ] if any(self.nodes[t].is_available(game_state) 
                     for _, t in node.choices) else None
        }
    
    def make_choice(self, choice_index, game_state):
        """Progress dialogue based on player choice."""
        if not self.current_node or not self.current_node.choices:
            return None
        
        _, target_id = self.current_node.choices[choice_index]
        return self.start_dialogue(target_id, game_state)

# Example usage
game_state = {'has_key': False, 'talked_to_guard': False}

system = DialogueSystem()
system.add_node(DialogueNode('intro', 'Guard', 
    "Halt! Who goes there?",
    choices=[
        ("I'm a traveler passing through", 'friendly'),
        ("None of your business", 'hostile'),
    ],
    effects={'started_conversation': True}
))
system.add_node(DialogueNode('friendly', 'Guard',
    "Ah, a traveler. The bridge is safe. Watch out for bandits north of here.",
    choices=[("Thank you, friend", 'end')],
    effects={'talked_to_guard': True}
))
system.add_node(DialogueNode('hostile', 'Guard',
    "Bold words for someone without a key to the gate. Come back when you have one.",
    effects={'guard_angry': True}
))
system.add_node(DialogueNode('end', 'Guard', 
    "Safe travels!"))

print(system.start_dialogue('intro', game_state))
# Player chooses option 0 (friendly)
print(system.make_choice(0, game_state))

class EnvironmentalStory:
    """
    Tell a story through objects, notes, and world state.
    Players piece together the narrative by exploration.
    """
    
    def __init__(self):
        self.clues = {}
        self.discovered = set()
        self.active_threads = {}
    
    def add_clue(self, clue_id, clue_type, content, 
                 location, connections=None, requires=None):
        """
        clue_type: 'note', 'object', 'corpse', 'graffiti', 'audio_log'
        connections: list of related clue_ids
        requires: clue_id that must be found first
        """
        self.clues[clue_id] = {
            'type': clue_type,
            'content': content,
            'location': location,
            'connections': connections or [],
            'requires': requires,
            'found': False
        }
    
    def discover_clue(self, clue_id, player_position):
        clue = self.clues.get(clue_id)
        if not clue:
            return None
        
        # Check if player is near enough
        dist = ((player_position[0] - clue['location'][0]) ** 2 +
                (player_position[1] - clue['location'][1]) ** 2) ** 0.5
        if dist > 5.0:
            return None
        
        # Check prerequisites
        if clue['requires'] and clue['requires'] not in self.discovered:
            return {'type': 'locked', 'message': 'You sense something hidden...'}
        
        clue['found'] = True
        self.discovered.add(clue_id)
        
        # Build narrative thread
        thread = {
            'title': self._guess_thread_title(clue),
            'clue': clue['content'],
            'connected_clues': [
                c for c in clue['connections'] 
                if c in self.discovered
            ],
            'progress': len(self.discovered)
        }
        
        return {
            'type': clue['type'],
            'content': self._format_clue(clue),
            'thread': thread,
            'story_progress': self._assemble_story()
        }
    
    def _assemble_story(self):
        """Synthesize discovered clues into narrative."""
        if len(self.discovered) < 2:
            return "You've found the beginning of a story..."
        
        # Order clues by discovery
        narrative_parts = []
        for cid in reversed(list(self.discovered)):
            clue = self.clues[cid]
            if clue['connections']:
                narrative_parts.append(clue['content'])
        
        return ' → '.join(narrative_parts[:3]) + ('...' if len(narrative_parts) > 3 else '')

# Build a murder mystery
story = EnvironmentalStory()
story.add_clue('bloodstains', 'visual', 
    'A trail of dark bloodstains leads from the library door to the window.',
    (10, 5), connections=['broken_vase'])
story.add_clue('broken_vase', 'object',
    'A shattered Ming vase. The murder weapon? A piece of cloth is caught on a shard.',
    (12, 5), connections=['note_suspect'], requires='bloodstains')
story.add_clue('note_suspect', 'note',
    '"Meet me at midnight. Come alone. — L" The handwriting is elegant, hurried.',
    (8, 8), connections=['hidden_dagger'], requires='broken_vase')

# Player discovers clues in order
for pos, cid in [((10, 5), 'bloodstains'), ((12, 5), 'broken_vase')]:
    result = story.discover_clue(cid, pos)
    if result:
        print(f"[{result['type'].upper()}] {result['content']}")
        print(f"  Story: {result['thread']['story_progress']}")

class Quest:
    def __init__(self, quest_id, title, description, 
                 objectives=None, rewards=None, prerequisites=None):
        self.id = quest_id
        self.title = title
        self.description = description
        self.objectives = objectives or []  # List of (description, is_complete_func)
        self.rewards = rewards or {}
        self.prerequisites = prerequisites or []  # Quest IDs that must be done first
        self.status = 'inactive'  # inactive, active, completed, failed
    
    def check_available(self, completed_quests):
        return all(q in completed_quests for q in self.prerequisites)
    
    def activate(self):
        self.status = 'active'
    
    def update_objectives(self, game_state):
        """Check objective completion conditions."""
        all_done = True
        for obj_desc, check_func in self.objectives:
            if not check_func(game_state):
                all_done = False
        return all_done
    
    def complete(self, player_state):
        self.status = 'completed'
        # Apply rewards
        for reward, value in self.rewards.items():
            if reward == 'xp':
                player_state['xp'] = player_state.get('xp', 0) + value
            elif reward == 'gold':
                player_state['gold'] = player_state.get('gold', 0) + value
            elif reward == 'item':
                player_state.setdefault('items', []).append(value)

class QuestManager:
    def __init__(self):
        self.quests = {}
        self.active_quests = []
        self.completed_quests = set()
    
    def add_quest(self, quest):
        self.quests[quest.id] = quest
    
    def check_new_quests(self, game_state):
        """Activate any newly available quests."""
        for qid, quest in self.quests.items():
            if quest.status == 'inactive' and quest.check_available(self.completed_quests):
                quest.activate()
                self.active_quests.append(qid)
                return f"New quest: {quest.title}"
        return None
    
    def update_quests(self, game_state):
        """Check all active quests for completion."""
        completed_now = []
        for qid in self.active_quests:
            quest = self.quests[qid]
            if quest.update_objectives(game_state):
                quest.complete(game_state)
                self.completed_quests.add(qid)
                completed_now.append(qid)
        
        self.active_quests = [q for q in self.active_quests 
                              if q not in completed_now]
        
        return completed_now

# Build a quest chain
manager = QuestManager()

manager.add_quest(Quest('find_key', 'Find the Cellar Key',
    "The innkeeper lost her cellar key. Search the garden.",
    objectives=[
        ("Find the key in the garden", lambda gs: gs.get('has_cellar_key')),
    ],
    rewards={'xp': 50, 'gold': 25}
))

manager.add_quest(Quest('clear_rats', 'Clear the Cellar Rats',
    "The cellar is infested with rats. Kill 5 of them.",
    objectives=[
        ("Kill 5 cellar rats", lambda gs: gs.get('rats_killed', 0) >= 5),
    ],
    prerequisites=['find_key'],
    rewards={'xp': 100, 'gold': 50}
))

# Simulate player progress
game_state = {'has_cellar_key': False, 'rats_killed': 0}

print(manager.check_new_quests(game_state))
# Player finds the key
game_state['has_cellar_key'] = True
manager.update_quests(game_state)
print(f"Completed: {list(manager.completed_quests)}")

print(manager.check_new_quests(game_state))
# Player kills rats
game_state['rats_killed'] = 5
completed = manager.update_quests(game_state)
print(f"Completed: {completed}")

class DialogueEditor:
    def __init__(self):
        self.nodes = {}
        self.current_id = 0
    
    def add_node(self, text, speaker="Narrator"):
        self.current_id += 1
        node = {
            'id': self.current_id,
            'speaker': speaker,
            'text': text,
            'choices': []
        }
        self.nodes[self.current_id] = node
        return self.current_id
    
    def add_choice(self, from_id, text, to_id):
        if from_id in self.nodes:
            self.nodes[from_id]['choices'].append((text, to_id))
    
    def export(self, filename):
        """Export to JSON for game engine."""
        data = {
            'nodes': [
                {
                    'id': nid,
                    'speaker': node['speaker'],
                    'text': node['text'],
                    'choices': node['choices']
                }
                for nid, node in self.nodes.items()
            ],
            'start_node': 1
        }
        with open(filename, 'w') as f:
            json.dump(data, f, indent=2)
        print(f"Exported {len(self.nodes)} nodes to {filename}")

# Create a dialogue tree
editor = DialogueEditor()
n1 = editor.add_node("Hello, traveler!", "Guard")
n2 = editor.add_node("The password for the gate is 'MORNINGSTAR'. Don't tell anyone I told you.", "Guard")
n3 = editor.add_node("Fine, freeze out here then.", "Guard")

editor.add_choice(n1, "What's the password?", n2)
editor.add_choice(n1, "None of your business", n3)
editor.export("dialogue.json")