diff --git a/docs/research/mass-effect-2-narrative-design-digest.md b/docs/research/mass-effect-2-narrative-design-digest.md new file mode 100644 index 0000000..4467dbd --- /dev/null +++ b/docs/research/mass-effect-2-narrative-design-digest.md @@ -0,0 +1,238 @@ +# Narrative Design in Mass Effect 2: Digest for Scenario Runner Work + +Source: [Interactive Storytelling in Mass Effect 2](https://www.youtube.com/watch?v=pMd5SS35KgM), a GDC 2010 talk by BioWare lead cinematic designer Armando Troisi. This digest is based on the generated English transcript captured at `.voidbot/artifacts/scenario-runner-research/pMd5SS35KgM.transcript.txt`; generated captions may contain name and wording errors. + +## One-Line Thesis + +Mass Effect 2 treats story and gameplay as one machine: the player's roleplay survives cinematic authorship only when every choice interface makes a clear promise and every authored result honors that promise. + +## The Core Problem + +BioWare wanted a cinematic, voiced, emotionally directed RPG without breaking the player's sense that Shepard was still their character. That creates a structural tension: + +- Traditional computer RPG dialogue gives the player high control, usually through verbatim lines and frequent choices. +- Cinematic presentation gives the writer, camera, actor, and editor stronger control over timing, emotion, and spectacle. +- If the cinematic layer acts without the player feeling represented, roleplay breaks. +- If the game pauses constantly for exact textual authorization, cinematic flow collapses. + +The talk's answer is not "more choices." It is a disciplined agreement between designer and player about what choices mean, how they are presented, when they appear, and what consequences they are allowed to produce. + +## Cinematic Design + +Troisi describes cinematic designers as narrative designers first and cinematic artists second. Their job is the "how" of interactive storytelling: tools, process, staging, camera, animation, dialogue, VO, and scripting all converge in the conversation system. + +The important point is that conversations are not just writing. They are the main interface through which the game communicates story intent, role, relationship, and player agency. A dialogue line is therefore also UI, animation, state mutation, pacing device, and player contract. + +For our scenario runner, this is the useful frame: utterance generation is not merely text output. It is the visible tip of a projection and action pipeline. If a Persona speaks, acts, withholds, interrupts, or escalates, the runner needs to preserve the intent contract all the way from inner interpretation to visible output. + +## Perspective: Subjective and Objective + +The talk separates RPG storytelling into two broad perspectives. + +Subjective perspective: + +- The player and avatar are treated as nearly identical. +- Dialogue choices are often verbatim. +- The avatar rarely acts without direct player instruction. +- Agency is high and explicit. +- The cost is temporal distortion: time freezes while the player reads and selects; NPCs often carry exposition while the player's character waits. + +Objective perspective: + +- The avatar is more visibly a character in the scene. +- Camera, acting, and timing can produce stronger cinematic emotion. +- The world can feel like it continues in real time. +- The cost is distance: the avatar may speak or act in a way the player did not intend. + +Mass Effect 2 tries to occupy a hybrid position: objective cinematic presentation with enough predictable choice grammar that players still feel they are roleplaying Shepard. + +For a Persona scenario runner, this maps directly onto the tension between authored character and agentic projection. A Persona should not be a puppet waiting for every explicit player command, but it also cannot violate its own established intent grammar and then call that "character." The runner needs a visible covenant for how inner state becomes action. + +## The BioWare Covenant + +Troisi names a covenant, or agreement, between designer and player. Its rules are the talk's most reusable design object: + +1. The interface for choice must be predictable. +2. A choice must produce the result the player expects. +3. The player should get the choices they want, when they want them. +4. It is the player's story; writers provide a multipath probability space. + +This is stronger than "support branching dialogue." It says the experience depends on preserving trust between option, implied intent, timing, and result. Once that trust breaks, the player stops inhabiting the role and starts defending against the interface. + +## The Conversation Wheel as a Promise Machine + +The Mass Effect conversation wheel replaced long list-based dialogue with short paraphrases arranged in consistent positions. It works because it carries two layers at once. + +Behavioral layer: + +- Position on the wheel has stable meaning. +- Upper/right and lower/right options develop moral or tonal associations, such as Paragon and Renegade. +- Investigate, neutral, friendly, hostile, exit, and action patterns become readable through placement. +- A reactive player can move quickly based on behavioral intent without parsing every word. + +Cognitive layer: + +- The text is a short paraphrase, not the exact voiced line. +- The paraphrase summarizes the intended thought or conversational move. +- It lets a reflective player reason about what Shepard is about to mean. + +The wheel is effective because these layers reinforce each other. The same short phrase means something different when placed in a compassionate, hostile, investigative, or decisive slot. The interface does not merely label content; it colors intent. + +For our runner, this suggests that player-facing and author-facing choices should expose intent grammar, not raw generated prose. A scenario action might show: + +- stance: reassure, challenge, probe, deflect, threaten, confess +- target: who or what the move is aimed at +- risk: what kind of social or material consequence it may invite +- sample utterance: a short paraphrase, not the full generated line + +The generated utterance can vary, but the promised move must remain stable. + +## Choice and Expected Result + +The talk uses a small example of moving the same action to different wheel positions to show how expectation changes. A friendly or Paragon-framed "tip the dancer" option reads as generous, respectful, or positive. Put the same action in a hostile or Renegade framing and the expected meaning changes. The surface text alone does not own the choice; the full presentation does. + +The failure case is the Citadel shopkeeper interaction. The player is offered something like "accuse of classism" without enough setup. Shepard then launches into a long manipulative exchange while the player mostly watches. The scene can be funny, but it violates the agreement: + +- The player lacked enough context to want that move. +- The option did not fully prepare them for the scale of Shepard's behavior. +- Once selected, the scene ran away without enough agency. +- The result felt like the character hijacked the player. + +The fix would not be a warning label. Troisi points toward setup: ambient lines, prior context, clearer framing, or more opportunities to steer. The system failed because it asked for a choice before earning the player's informed desire. + +For a scenario runner, this is a hard rule: do not ask the player, director, or Persona to commit to an action whose social meaning has not been made legible. If the generated action is going to dominate, shame, seduce, betray, forgive, kill, or permanently alter a bond, the runner must surface the real move before executing it. + +## Choices Players Want, When They Want Them + +Mass Effect 2's interrupt system exists to close an emotional loop at the moment the player feels it. If a villain is monologuing and the player wants to hit them, the Renegade interrupt appears at that dramatic pressure point. If Tali is grieving and the player wants to comfort her, the Paragon interrupt lets Shepard hug her. + +The interrupt matters because it appears when the desire is already present. It does not merely add optional activity. It recognizes a felt impulse and gives the player a clean way to express it. + +That timing is critical for roleplay. A choice offered too early is confusing. A choice offered too late feels like bureaucracy. A choice offered at the moment of emotional readiness feels like the game understood the player. + +For a Persona-driven RPG, this points toward scenario prompts that watch for pressure: + +- social pressure: someone is hurt, insulted, cornered, or exposed +- moral pressure: a value has been violated +- tactical pressure: an opening appears +- relationship pressure: a bond asks to be defended, deepened, tested, or cut +- identity pressure: the Persona's self-concept is being challenged + +The runner should not only ask "what can happen next?" It should ask "what action would the player or Persona be aching to take now?" + +## The Player's Story as Probability Space + +Troisi frames authored narrative as a multipath probability space. The writers build the possibility field; the player authors their path through it. + +The Mass Effect 1 council decision shown through Mass Effect 2 Citadel ads is the simple example: old choices reappear as world texture. The state is not only a branch in a quest file. It becomes propaganda, film marketing, gendered Shepard footage, tone, public memory, and the world's interpretation of past action. + +For our scenario runner, this is gold. Persistent Persona state, bonds, memories, and world facts should not only unlock binary branches. They should flavor: + +- what NPCs assume +- what rumors circulate +- how factions frame prior events +- what options appear natural +- what emotional pressure a Persona feels +- what the world thinks the protagonist's story means + +A good runner should lower state into scene pressure, not just query it for flags. + +## Interrupts Need Telegraphs + +The talk ends by warning that even an interrupt icon is not enough if the action itself is ambiguous. A Renegade interrupt might mean punch, shoot, shove, threaten, insult, or something worse. If the player cannot predict the actual action, they may press the button and immediately feel betrayed. + +Mass Effect 2 solves this with cinematic telegraphing. In the suspect interrogation example, Shepard cracking his knuckles before the interrupt makes the likely action clear. The player knows the category and the specific physical implication. + +This is the visual version of a paraphrase. It does not spoil every detail, but it tells the player what kind of act they are authorizing. + +For the scenario runner: + +- A text option needs an intent paraphrase. +- A physical action needs a visible or textual telegraph. +- A social action needs a relationship consequence hint. +- A magical or tactical action needs a target and risk hint. +- A Persona utterance needs stance, audience, and likely emotional vector. + +Do not hide the real move in the generated prose and pretend the player consented because they clicked a vague verb. + +## Design Lessons for a Persona Scenario Runner + +The runner should preserve a covenant among player, Persona, scenario, and world state. + +Choice surfaces should be predictable: + +- Use stable positions, icons, colors, or labels for recurring intent families. +- Keep the same intent grammar across dialogue, action, combat, and relationship scenes. +- Separate "ask for information" from "make a claim," "take action," "change relationship," and "commit to danger." + +Choices should produce expected results: + +- Every option should carry enough preview to define the authorized move. +- Generated output may be richer than the preview, but it must not reverse the preview's intent. +- If model generation changes the move, the runner should reject or revise before display. + +Choices should appear when wanted: + +- Track scene pressure, not just turn count. +- Offer interrupts when emotional, tactical, or relational pressure crests. +- Let Personas generate candidate impulses, then lower them into selectable or auto-executable moves depending on authority. + +The player's story should remain theirs: + +- Store consequences as world memory, not just branch flags. +- Let prior choices change framing, rumor, available options, and emotional default. +- Preserve authored state as a possibility field, not a railroad pretending to branch. + +## Weksa / Persona Interlingua Implications + +If existing VoidBot Personas are dropped into a roleplaying scenario through Weksa's interlingua lowerer, the lowerer should not simply convert Persona thoughts into dialogue. It needs to preserve the covenant layers: + +- projection: what the Persona privately believes, feels, notices, and wants +- interpretation: what the Persona thinks the scene means +- candidate move: what the Persona wants to do or say +- intent paraphrase: what the player/director can understand before it happens +- telegraph: what the world can see before or during commitment +- utterance/action: the actual lowered output +- consequence update: how bonds, memory, world state, and scene pressure change + +The interlingua should carry intent as first-class state. If it only carries final prose, the system loses the difference between "teasing," "threatening," "testing loyalty," and "trying not to cry while pretending to joke." That difference is the actual roleplay. + +## Scenario Runner Shape + +A coherent runner loop could look like this: + +1. Scene state loads current location, participants, hazards, goals, recent events, and relevant memories. +2. Each Persona projects private reads: desire, fear, values, bonds, assumptions, and candidate impulses. +3. The runner identifies pressure points: moments where a player or Persona would naturally want to intervene. +4. Weksa lowers candidate moves into friendly intent options with stance, target, risk, and paraphrase. +5. The selected or authorized move becomes utterance/action generation. +6. A verifier checks that generated output honors the intent contract. +7. Consequences update world facts, bonds, short-term memory, long-term memory pressure, and future scene affordances. + +The crucial invariant: private Persona machinery may be rich, weird, and high-dimensional, but the playable surface must be legible enough for consent and authorship. + +## Anti-Patterns + +Do not present vague options that secretly encode extreme actions. + +Do not let a generated utterance hijack the selected intent. + +Do not treat "more branches" as a substitute for clearer choice grammar. + +Do not offer choices before the scene has created the desire for them. + +Do not make persistent consequences invisible until they ambush the player. + +Do not flatten Persona state into final dialogue. The runner needs projection, interpretation, intent, telegraph, action, and consequence as separate surfaces. + +## Short Version for Implementation + +Mass Effect 2's lesson is that cinematic roleplay works when authored presentation and player agency share a stable contract. For Ghostlight-shaped RPG scenarios, that means the scenario runner should treat every Persona action as a promise-bearing move: + +- What does the actor intend? +- How does the player/director know that before authorizing it? +- What visible telegraph makes the action fair? +- What output is allowed under that intent? +- What state changes prove the world understood it? + +If those questions are answered, existing Personas can enter adventure RPG scenes without losing their projection, interpretation, and utterance machinery. If they are not answered, the system will generate impressive dialogue that occasionally steals the story from the person trying to play it. diff --git a/docs/research/rpg-sprawl-limited-animation-budget.md b/docs/research/rpg-sprawl-limited-animation-budget.md new file mode 100644 index 0000000..dc1d2ad --- /dev/null +++ b/docs/research/rpg-sprawl-limited-animation-budget.md @@ -0,0 +1,269 @@ +# Sprawling RPGs on a Limited Animation Budget + +Research question: how do games like Mass Effect, The Witcher 3, and adjacent large RPGs create the feeling of a vast roleplaying experience without hand-animating every possible scene as bespoke film? + +Short answer: they do not animate the sprawl directly. They build a repeatable performance grammar, generate or assemble a strong first pass from reusable parts, reserve custom work for emotional peaks, and make player choice feel large through stateful framing, consequence visibility, and authored quest structure. + +## Sources Consulted + +- [Interactive Storytelling in Mass Effect 2](https://www.youtube.com/watch?v=pMd5SS35KgM), Armando Troisi, GDC 2010. Local transcript: `.voidbot/artifacts/scenario-runner-research/pMd5SS35KgM.transcript.txt`. +- [Behind the Scenes of Cinematic Dialogues in The Witcher 3: Wild Hunt](https://www.gdcvault.com/play/1023285/Behind-the-Scenes-of-Cinematic), Piotr Tomsinski, GDC 2016. GDC describes the talk as covering The Witcher 3's dialogue system, pipeline, tools, editor, animation problems, and production solutions. +- [PC Gamer write-up of Tomsinski's Witcher 3 talk](https://www.pcgamer.com/most-of-the-witcher-3s-dialogue-scenes-was-animated-by-an-algorithm/), including Tomsinski's later clarification that the generator was a first-pass tool, not the source of final cinematic judgment. +- [10 Key Quest Design Lessons from The Witcher 3 and Cyberpunk 2077](https://gdcvault.com/play/1028897/10-Key-Quest-Design-Lessons), Pawel Sasko, GDC 2023. Local transcript: `.voidbot/artifacts/scenario-runner-research/nAkH86__g0o.witcher3-cyberpunk-quest-lessons.transcript.txt`. +- [Procedural Generation of Cinematic Dialogues in Assassin's Creed Odyssey](https://gdcvault.com/play/1026381/Procedural-Generation-of-Cinematic-Dialogues), Francois Paradis, GDC 2019. GDC says Odyssey shipped around 30 hours of cinematic content, about 15% fully procedural, with procedural elements present across all scenes. +- [BioWare dialogue wheel patent](https://patents.google.com/patent/US20070226648A1/en), useful for the consistent-mapping logic behind fast, learnable dialogue choices. +- [10 Facts About Mass Effect's Animation](https://medium.com/%40EightyLevel/10-facts-about-mass-effects-animation-47f94d7c1c49), 80 Level/GameAnim summary of Mass Effect animation practices. +- [Animators Roundtable: The Mass Effect Andromeda pile-on](https://www.gamedeveloper.com/design/animators-roundtable-the-i-mass-effect-andromeda-i-pile-on), Game Developer, for a general explanation of how large dialogue systems rely on phonemes, emotional shapes, body-language sets, look-at systems, and procedural stitching rather than custom acting per line. + +## The Production Problem + +Big cinematic RPGs contain impossible quantities of conversation if treated like linear film. The Witcher 3 had dozens of hours of dialogue and 1,463 cinematic dialogues according to the PC Gamer/Tomsinski write-up. Assassin's Creed Odyssey introduced roughly 30 hours of cinematic dialogue content. Mass Effect 2 had tens of thousands of voiced lines and a design goal of making conversations feel close to real-time, cinematic exchanges. + +No team can give every line the Uncharted treatment. Fully bespoke animation for every branch would destroy schedule, budget, localization, and iteration speed. The solution is to make the common case cheap and reliable while protecting a path for expensive craft at the moments that deserve it. + +## Pattern 1: Standardize the Choice Grammar + +Mass Effect's conversation wheel is a budget tool as much as a UX tool. Stable positions on the wheel map to stable classes of intent: investigate, friendly, hostile, Paragon, Renegade, conclude, and so on. The patent describes this as consistent mapping: the player learns where classes of response live, so selection becomes faster and closer to conversational rhythm. + +This saves animation and writing budget indirectly: + +- Writers design within a known set of conversational moves. +- Cinematic designers can predict what kind of performance beat a choice represents. +- Players accept short paraphrases instead of needing full verbatim lines. +- The system can reuse stance, camera, and pacing patterns because the interaction grammar is stable. + +The trick is not that all conversations become the same. The trick is that the interface carries enough invariant meaning that custom content can be smaller. The wheel position and paraphrase do part of the acting before Shepard speaks. + +Runner implication: define a small set of reusable scene-move classes before generating dialogue. For example: probe, reassure, challenge, threaten, bargain, confess, joke, withdraw, act, interrupt. If every move is freeform text, every move requires bespoke interpretation. If every move has a class, target, and risk, Weksa can lower it into many scenes without rebuilding the whole stage. + +## Pattern 2: Separate Performance Layers + +Large RPG conversation systems split performance into layers: + +- voice line and timing +- generated or authored lip sync +- facial expression +- eye and head look-at +- body pose +- gesture +- camera framing +- blocking and placement +- scene timing and cuts + +Game Developer's animator roundtable describes the common approach: instead of custom animation per line, teams build phoneme shapes, emotion shapes, body-language sets at intensities, and procedural systems for look-at, head tracking, and lip sync. Mass Effect similarly used procedural lip sync for localization, eye constraints to fight dead stares, and conversation-system access to a broad animation library. + +Layering is the multiplier. A gesture can be reused with different facial emotion. A look-at can make a canned pose feel responsive. A camera cut can hide a transition. Lip sync can be generated from VO while animators spend time on expression and staging. + +Runner implication: do not treat a Persona output as one blob. Split it into intent, utterance, facial/affect beat, gaze/attention, body/action beat, camera or prose focus, and consequence. Even in text-only form, those layers let the system vary presentation cheaply. + +## Pattern 3: Generate the First Pass, Then Polish Meaning + +The Witcher 3's cinematic dialogue system is the cleanest example. CDPR built a generator that filled a timeline with basic units. Inputs included actor information, cinematic instructions, and extracted voiceover data. The system generated camera movement and placement, facial animation, body animation, and look-ats. Designers could regenerate, then edit. + +The important correction is that CDPR did not claim procedural generation replaced cinematic design. Tomsinski later clarified that the generator created a rough first pass, then every cinematic dialogue was approached with care; many scenes were customized from the start. The production win was not "the algorithm did art." The win was "the algorithm gave the artist a scene-shaped object to improve instead of a void." + +This is the sane version of automation. Generate the boring scaffolding. Let humans, high-level models, or specialized directors spend attention on emotional truth, pacing, shot choice, and meaning. + +Runner implication: the scenario runner should generate a draft staging pass automatically: + +- who is speaking +- who is looking at whom +- default posture +- emotional register +- rough utterance +- expected beat length +- consequence target + +Then a verifier/director pass should polish or reject only the parts that matter: intent mismatch, emotional peak, bond change, irreversible action, or tonal failure. + +## Pattern 4: Build a Reusable Acting Library + +The Witcher 3 system depended on reusable animation blocks. The PC Gamer write-up describes a library of 2,400 dialogue animations across character types and poses, which becomes much smaller once divided among men, women, dwarves, elves, children, standing, sitting, kneeling, and so on. The system used additive animations and masking so, for example, an arm gesture could play while a character remained seated instead of snapping into a standing full-body animation. + +That is the core budget hack: + +- body parts can animate independently +- gestures can survive posture changes +- poses can be combined with look-ats and facial beats +- animation data can be retargeted across compatible character classes +- masking prevents the whole body from being hostage to one gesture + +Runner implication: give Personas a reusable "acting lexicon" rather than asking the model to invent fresh physical prose every time. The lexicon can be abstract at first: + +- stillness +- glance away +- lean in +- half-smile +- open hand +- guarded posture +- hard stare +- interruption beat +- step back +- touch object + +The lowerer can combine these with affect and intent. Later, if this becomes visual, those same abstract beats can map onto animation clips. + +## Pattern 5: Use Camera and Editing as Cheap Emotional Amplifiers + +Camera work is cheaper than bespoke body acting when the system has reusable shot grammar. Mass Effect leaned on close-ups and long lenses to put emotional weight on faces. The Witcher 3 pipeline could generate and then hand-adjust camera movement, placement, cuts, and lingering reaction shots. Tomsinski's clarification stresses that compelling scenes come from editing, staging, cinematography, and choosing when to show reaction. + +The practical lesson: expensive animation is not the only way to make a scene feel authored. You can sell a moment through: + +- close-up instead of full-body motion +- reaction shot instead of new action +- cutaway to an object or listener +- pause before response +- character looking away +- silence or shortened line +- controlled framing that hides reuse + +Runner implication: even a text runner can use focus control. Instead of always emitting dialogue, it can emit: + +- "Camera" equivalent: whose perception anchors the beat +- "Reaction" equivalent: who visibly absorbs the line +- "Pause" equivalent: whether the scene breathes before the next move +- "Cutaway" equivalent: what object, wound, door, weapon, or crowd detail carries meaning + +This makes scenes feel staged without spending a new animation every turn. + +## Pattern 6: Spend Custom Work on Peaks + +AAA RPGs survive by triage. The common case gets generated or assembled. The peak moments get custom attention. + +Mass Effect's interrupts are authored around emotional pressure: hit the villain when the player wants to hit him, hug Tali when the player wants to comfort her. The Witcher 3 and Cyberpunk quest lessons emphasize emotional moments, artistic bravery, and scenes whose subject matter earns unusual treatment. The Bloody Baron botchling sequence works because it is not just shocking content; it is an emotionally specific ritual about guilt, violence, fatherhood, and attempted repair. + +The lesson is not "never reuse." It is "know when reuse becomes betrayal." + +Custom budget should go to: + +- irreversible moral choices +- bond formation or rupture +- death, mercy, betrayal, confession, or intimacy +- major reveals +- scenes where physical action carries the meaning +- moments the player will remember as the story + +Runner implication: flag high-stakes beats before lowering. A normal barter scene can use standard beats. A Persona admitting love, choosing exile, violating a core value, killing someone, or changing a bond should trigger stricter review and richer staging. + +## Pattern 7: Make Consequences Visible, Not Just Present + +Pawel Sasko's quest-design talk is especially useful here. He argues that consequences need visibility. If a consequence exists only as a subtle radio line, TV variation, or obscure NPC placement, many players will assume the game did not react at all. + +This matters for budget. A sprawling RPG cannot branch every quest into a whole alternate campaign, but it can make prior choices reappear through visible texture: + +- an NPC recognizes the player +- a faction changes tone +- a poster, rumor, radio line, or ad reframes the event +- a saved or harmed person appears later +- a location changes slightly +- a companion comments +- an available option changes + +Mass Effect 2 does this with imported Mass Effect 1 choices appearing as Citadel media and public memory. Witcher/Cyberpunk examples use returning characters, scene entrances, radio/TV, and later quest framing. + +Runner implication: do not spend all consequence budget on branch depth. Spend heavily on consequence projection. If a Persona or player changes something, the world should show it in cheap but legible ways: greeting, rumor, avoidance, new nickname, altered bond posture, faction offer, environmental scar. + +## Pattern 8: Avoid Wasteful Branch Splits + +The Witcher 2's famous mid-game split is thrilling from a player perspective but expensive because large amounts of content become mutually exclusive. Later CDPR discussion around The Witcher 3 and Cyberpunk points toward a more sustainable pattern: keep the world rich and reactive without routinely building two separate games in parallel. + +Useful forms of efficient branching: + +- local branch, global reconvergence +- different route to same confrontation +- different emotional meaning for same event +- different witnesses or allies in same scene +- delayed consequence in cheap texture +- altered dialogue/camera/framing over altered level geometry +- one bespoke peak branch, not bespoke everything + +Bad branching spends full production cost on content most players never see and that cannot be recombined. + +Runner implication: scenario branches should usually reconverge at scene goals while preserving authored differences in memory, bonds, resources, and reputation. Let the state carry the uniqueness. Do not fork the entire adventure unless the fork itself is the point. + +## Pattern 9: Use Subtraction and Subtle Exposition + +Sasko's quest talk repeatedly returns to brevity. Cut busy work. Do not make characters repeat information the player already has. Let the world imply values through props, ads, costumes, and routine behavior instead of explaining every detail. + +This also saves animation. If a repeated explanation can become a cut, a visible clue, or a world detail, the team avoids staging another talk scene. + +Runner implication: a scenario runner should treat exposition as expensive. Before generating an explanatory exchange, ask: + +- Can the player infer this from the scene? +- Can an object carry it? +- Can a remembered consequence carry it? +- Can an NPC reaction carry it? +- Can the line be cut because the player already knows? + +Text is cheap computationally, but attention is not. Infinite generated explanation is how an RPG becomes a filing cabinet with swords. + +## Pattern 10: Make Reuse Diegetic + +Reuse feels cheap when the player sees the machine. Reuse feels rich when it matches a stable cultural, physical, or social grammar. + +Examples: + +- Mass Effect's wheel positions become Shepard's conversational grammar. +- Witcher 3's recurring gestures feel like human conversational habits if gaze, facial expression, and timing vary. +- Open-world rumor, noticeboard, merchant, guard, and companion-comment structures make repeated delivery channels feel like part of the world. +- Quest genres such as investigation, contract, negotiation, ambush, ritual, and aftermath create reusable staging frames with different emotional payloads. + +Runner implication: define reusable scenario forms in-world: + +- tavern rumor +- road encounter +- campfire confession +- interrogation +- contract negotiation +- ruins investigation +- faction audience +- aftermath visit +- companion aside +- public accusation + +Then vary target, stakes, bond pressure, consequence, and emotional tone. The repeated frame becomes genre literacy instead of visible budget damage. + +## Practical Architecture for Our Scenario Runner + +The runner should split RPG scene generation into authorities: + +1. Scenario state: location, participants, objectives, hazards, prior consequences. +2. Persona projection: private desire, values, bonds, fears, current read. +3. Move grammar: stable action/dialogue classes with target and risk. +4. Staging generator: default camera/focus, posture, gaze, gesture, beat timing. +5. Utterance/action lowerer: Weksa turns intent into speech/action. +6. Verifier: checks generated output against selected intent and budget tier. +7. Consequence projector: writes visible and durable effects into world, bonds, memory, and future affordances. + +The budget tier matters: + +- Ambient: generated staging, reusable beats, minimal verification. +- Standard quest: generated first pass, model/director polish, visible consequence. +- Peak: custom scene plan, stricter intent verification, richer reaction/focus, durable memory write. +- Irreversible: explicit consent/preview, no vague option labels, consequence projection required. + +## Design Rules + +Use stable intent classes. Do not make players infer meaning from raw prose alone. + +Generate first-pass staging. Do not hand-author every ordinary exchange. + +Keep performance layered. Facial beat, gaze, posture, camera/focus, and utterance should be separately controllable. + +Spend custom attention on emotional peaks. Reuse should serve the boring connective tissue. + +Make consequences visible. A hidden state change is not roleplay feedback. + +Prefer reconvergent branching with persistent meaning over full-content divergence by default. + +Cut repeated exposition. Let scene evidence, props, social reactions, and world texture carry information. + +Use diegetic templates. Repeated scene forms feel better when the world itself explains them. + +## The Real Lesson + +Sprawling RPGs are not made by brute-forcing infinity. They are made by turning authorship into a machine with a humane control panel. + +Mass Effect standardizes conversational intent so cinematic presentation can move fast without stealing the player's role. The Witcher 3 builds a reusable cinematic dialogue factory, then lets human designers polish the moments where meaning lives. Cyberpunk and Witcher quest design keep the player hungry through subtraction, emotional dilemmas, visible consequences, and selective bravery. Assassin's Creed Odyssey shows the same production pressure at another scale: procedural cinematic assembly can cover enormous dialogue volume, but the system still needs designers to decide what matters. + +For Ghostlight-shaped Persona RPGs, the path is clear enough to start cutting metal: make a reusable move grammar, lower Persona state into layered performance, generate cheap staging by default, verify intent before output, and project consequences visibly back into world and relationship state. That is how the dream gets large without requiring a bespoke little opera every time someone asks where the road goes. diff --git a/state/evidence.jsonl b/state/evidence.jsonl index 5142945..1bad344 100644 --- a/state/evidence.jsonl +++ b/state/evidence.jsonl @@ -347,3 +347,4 @@ {"ts":"2026-06-11T21:21:01Z","type":"implementation","status":"ok","note":"Generated docs/persona-intake/metame.persona-intake.yaml from native Persona CultCache state at .voidbot/private/personas/metame/metame.cc and updated the friendly Persona exporter to support native Persona state without an identity JSON file."} {"ts":"2026-06-11T21:32:25Z","type":"implementation","status":"ok","note":"Reworked persona friendly intake projection so memories, affect, bonds, doctrine, agency pressure, and actions read as human-editable cards with compact source blocks instead of raw typed-state schema dumps; regenerated Sai and Metame examples."} {"ts":"2026-06-11T21:39:59Z","type":"implementation","status":"ok","note":"Changed friendly Persona intake export to omit per-item source/provenance by default, with --include-source as the opt-in forensic path. Regenerated Sai and Metame so memory sections read as compact human-editable cards."} +{"ts":"2026-06-12T10:09:54Z","type":"research","status":"ok","note":"Distilled RPG cinematic-dialogue production patterns from Mass Effect 2, Witcher 3/Cyberpunk quest design, Witcher 3 dialogue tooling, and AC Odyssey procedural dialogue sources into docs/research/rpg-sprawl-limited-animation-budget.md for Ghostlight scenario-runner design."}