Interactive Theatre Designer

Participation Modes

Branching Narrative Design

Structure Types

Linear with Variations
A ──→ B ──→ C ──→ D
      ↓
      B' (variation based on earlier choice)

Branching Tree
      ┌── B1 ──→ C1
A ────┤
      └── B2 ──→ C2 ──┬── D1
                      └── D2

Folding Paths (reconvergent)
      ┌── B1 ──┐
A ────┤        ├──→ D
      └── B2 ──┘

Hub and Spoke
         ┌── B ──┐
    ┌────┤       │
A ──┤    └───────┘
    │    ┌── C ──┐
    └────┤       │
         └───────┘

Parallel Threads
A1 ───────→ B1 ───────→ C1
            ↕ sync
A2 ───────→ B2 ───────→ C2

Choice Architecture

class NarrativeChoice:
    """A decision point in the story"""

    def __init__(self, prompt, options):
        self.prompt = prompt
        self.options = options
        self.context_requirements = []
        self.consequences = {}

    def evaluate_options(self, audience_state):
        """Determine available choices based on state"""
        available = []
        for option in self.options:
            if option.is_available(audience_state):
                available.append(option)

        # Always ensure at least two meaningful options
        if len(available) < 2:
            available.append(self._create_fallback_option())

        return available


class StoryBeat:
    """A unit of narrative action"""

    def __init__(self, content, duration_range, choice=None):
        self.content = content
        self.min_duration = duration_range[0]
        self.max_duration = duration_range[1]
        self.choice = choice  # Optional NarrativeChoice
        self.state_changes = {}  # What this beat modifies
        self.prerequisites = []  # What must be true to reach this

Consequence Systems

class ConsequenceTracker:
    """Track choices and their ripple effects"""

    def __init__(self):
        self.choices_made = []
        self.world_state = {}
        self.character_relationships = {}
        self.available_endings = set()

    def record_choice(self, choice_id, option_selected, timestamp):
        self.choices_made.append({
            'choice': choice_id,
            'selected': option_selected,
            'time': timestamp
        })
        self._apply_consequences(choice_id, option_selected)
        self._update_available_endings()

    def _apply_consequences(self, choice_id, option):
        """Apply immediate and delayed consequences"""
        # Immediate effects
        for effect in option.immediate_effects:
            self._apply_effect(effect)

        # Queue delayed effects
        for effect in option.delayed_effects:
            self._queue_effect(effect)

    def get_story_fingerprint(self):
        """Unique identifier for this audience's journey"""
        return hash(tuple(
            (c['choice'], c['selected'])
            for c in self.choices_made
        ))

Audience Agency Design

Choice Design Principles

Make Choices Meaningful:

• Clear stakes: What's at risk?
• Visible consequences: Changes they can observe
• Emotional investment: Characters they care about
• No "right" answer: Multiple valid paths

Avoid Choice Paralysis:

• Limit to 2-4 options at decision points
• Provide adequate context (but not too much)
• Use time pressure sparingly and purposefully
• Signal importance level of choices

Voting and Collective Choice

class CollectiveDecision:
    """Aggregate audience input into story decisions"""

    def __init__(self, voting_method='plurality'):
        self.voting_method = voting_method
        self.votes = {}

    def collect_votes(self, options, timeout_seconds=30):
        """Gather votes from audience"""
        # Methods: raise hands, mobile app, physical movement, sound
        pass

    def resolve(self):
        """Determine outcome based on voting method"""
        methods = {
            'plurality': self._plurality,      # Most votes wins
            'supermajority': self._supermajority,  # Needs 2/3
            'consensus': self._consensus,      # Unanimous
            'weighted': self._weighted,        # Some votes count more
            'random_delegate': self._delegate  # One person decides
        }
        return methods[self.voting_method]()

    def _plurality(self):
        return max(self.votes.keys(), key=lambda x: self.votes[x])

Individual vs Collective Agency

Immersive Environment Design

Space as Narrative

TRADITIONAL STAGE          IMMERSIVE SPACE

┌─────────────────┐       ┌─────────────────────────────┐
│                 │       │  GARDEN    │    LIBRARY    │
│      STAGE      │       │  (Past)    │    (Memory)   │
│                 │       │     ◇      ↔      ◇        │
├─────────────────┤       ├────────────┼───────────────┤
│    AUDIENCE     │       │  KITCHEN   │    BEDROOM    │
│                 │       │  (Present) │    (Future)   │
└─────────────────┘       │     ◇      ↔      ◇        │
                          └─────────────────────────────┘
                               ◇ = Performance hotspot
                               ↔ = Audience flow path

Environmental Storytelling Elements

class ImmersiveSpace:
    """Design an immersive theatrical environment"""

    def __init__(self, venue):
        self.venue = venue
        self.zones = {}
        self.artifacts = []
        self.ambient_states = {}

    def add_zone(self, zone):
        """Define a narrative zone"""
        self.zones[zone.name] = zone

    def design_discovery_path(self, story_beats):
        """Create environmental narrative arc"""
        path = []
        for beat in story_beats:
            zone = self._select_zone_for_beat(beat)
            artifacts = self._place_artifacts(beat, zone)
            ambient = self._set_ambient_state(beat, zone)
            path.append({
                'beat': beat,
                'zone': zone,
                'artifacts': artifacts,
                'ambient': ambient
            })
        return path


class NarrativeArtifact:
    """Object that tells story when discovered"""

    def __init__(self, name, backstory, discovery_trigger):
        self.name = name
        self.backstory = backstory  # What it reveals
        self.discovery_trigger = discovery_trigger  # How found
        self.required_for_story = False
        self.hidden_level = 0  # 0=obvious, 5=very hidden

Sensory Design

Live System Design

Real-Time Adaptation

class ShowController:
    """Manage live show based on audience behavior"""

    def __init__(self, script, performers, systems):
        self.script = script
        self.performers = performers
        self.systems = systems  # Lights, sound, effects
        self.current_beat = None
        self.audience_state = AudienceState()

    def update(self):
        """Called continuously during show"""
        # Observe audience
        self.audience_state.update(self._observe_audience())

        # Check for triggers
        triggers = self._check_triggers()

        # Adapt if needed
        for trigger in triggers:
            self._handle_trigger(trigger)

        # Cue performers
        self._send_performer_cues()

    def _check_triggers(self):
        """Detect conditions that require adaptation"""
        triggers = []

        # Audience engagement low
        if self.audience_state.engagement < 0.3:
            triggers.append(('low_engagement', 'intensify'))

        # Audience moving to unexpected zone
        if self._unexpected_movement():
            triggers.append(('migration', 'redirect_or_adapt'))

        # Time running over/under
        pace = self._calculate_pace()
        if pace < 0.8:
            triggers.append(('slow_pace', 'compress'))
        elif pace > 1.2:
            triggers.append(('fast_pace', 'expand'))

        return triggers

Performer Communication

class PerformerCueSystem:
    """Real-time communication with performers"""

    def __init__(self):
        self.performers = {}
        self.cue_queue = []

    def add_performer(self, name, device_type):
        """Register performer with their cue device"""
        self.performers[name] = {
            'device': device_type,  # 'earpiece', 'wearable', 'visual'
            'current_track': None,
            'status': 'ready'
        }

    def send_cue(self, performer, cue_type, content, urgency='normal'):
        """Send cue to specific performer"""
        cue = {
            'performer': performer,
            'type': cue_type,  # 'go', 'hold', 'redirect', 'improv'
            'content': content,
            'urgency': urgency
        }
        self._transmit(cue)

    def broadcast_state_change(self, new_state):
        """Inform all performers of story state change"""
        for performer in self.performers:
            self.send_cue(
                performer,
                'state_change',
                new_state,
                urgency='low'
            )

Documentation and Planning

Show Bible Structure

## [Show Title] Production Bible

### Concept
- Logline (one sentence)
- Themes
- Audience experience goals

### Narrative
- Story summary (non-branching core)
- Branch points and options
- Endings (and how reached)
- Character breakdowns

### Space
- Venue requirements
- Zone map
- Artifacts inventory
- Technical requirements

### Interactivity
- Choice points catalog
- Participation mechanics
- Edge cases and recovery

### Operations
- Audience journey map
- Performer tracks
- Stage management protocol
- Emergency procedures

Run Sheet Format

TIME    | BEAT           | ACTION                | TRIGGERS
--------|----------------|----------------------|------------------