The Complete Scenario Architecture — Weaving It All Together

 

Over 19 parts, we designed individual elements. Now it is time to weave them all together. Here is the complete picture of the design built with AI.

System Architecture Summary

This visual novel runs on three core systems.

1. Emotion System (3 Layers)

Layer A - Fundamental Disposition: need_for_affection, fear_of_rejection, pride, insecurity
Layer B - Momentary Emotion: affection, anger, sadness, jealousy, admiration, fear
Layer C - Relationship State: trust, reliance, intimacy, tension, resentment, respect

Love is not a variable. It emerges from the combination of Layer C variables.

2. Context System

location: 5 locations
time: 4 time periods
weather: 4 weather types (not player-controllable)
privacy: 3 levels
mood: 5 atmospheres

The same event creates different emotions depending on context.

3. Memory System

Pattern tracking: did_not_ask, avoided_confession, missed_timing, etc.
Event flags: shared_umbrella, saw_with_rival, broke_promise, etc.
Accumulation counters: repeated patterns amplify their impact

The results of choices are delayed. Their meaning changes later.

How Scenes Work

Every scene opens at the intersection of these three systems.

Emotion condition met + Context condition met + Memory flag met
-> Specific event triggers
-> Emotion changes + New memory stored

Example: "A Conversation Where Inner Feelings Come Out"

if (rel["trust"] >= 40 and 
    scene_ctx["time"] == "night" and 
    scene_ctx["weather"] == "rain" and 
    scene_ctx["privacy"] >= 1 and
    flags["did_not_ask"] < 2):
    jump vulnerable_conversation

If trust has been built, it is night, it is raining, they are alone, and the player has not avoided too many times before — a conversation where inner feelings emerge is unlocked.

When I asked the AI to verify this code, an interesting piece of feedback came back. "What happens when did_not_ask is exactly 2?" A boundary value question. One avoidance is fine and three is blocked, but what about two? Because AI pressed persistently on these fine-grained boundaries, the trigger conditions for each scene became much more precise. When designing alone, it is easy to gloss over with "roughly 2 or 3."

Character Design Principles

Action != Inner self (dissonance creates appeal)
Expression ability can differ from emotional depth
Change is gradual, but the cause is the player's choices
Layer A (personality) barely changes; only Layer C (relationship) shifts

Conflict Design Principles

Conflict without villains > villain-driven conflict
Good intentions vs good intentions (clash of love languages)
Internal conflict > external conflict
The paradox of caring, the paradox of protection, the paradox of respect

Time Structure

[Prologue] Seeds of memory — ends incomplete
[Act 1] Reunion and awkwardness — choices have almost no impact
[Act 2] Entangled relationships — choices accumulate, consequences delayed
[Turning Point] Relationship breaks — happens inevitably
[Act 3] The real game — past choices detonate, final choice

The excitement of each period is different. Comfort -> unfamiliar excitement -> anxious excitement -> responsible emotion.

What the AI and I discussed most when designing this time structure was the "turning point" section. The moment when the relationship must break. The reason we set this as "inevitable" was the conflict design principle from Part 5. The collision of good intentions cannot be avoided. The moment where actions meant for each other wound each other must come. Without this turning point, Act 3 loses its weight. When I asked the AI "What happens if we skip the turning point and go straight to Act 3?" the answer was "The player cannot feel the consequences of their own choices." Exactly right. You have to see the relationship break before you understand the weight of what you have built.

Ending Structure

Connected: trust high + avoidance low + mutual emotion
Late Love: trust high + avoidance high
Ruin: affection high + hurt deep
Passing By: incomplete emotion

Ending conditions are hidden from the player. The experience of accepting the result of one's own choices.

Weather System

Weather is not controllable by the player. For key scenes, the scenario determines the weather; for everyday scenes, the system determines it. Uncontrollability acts like fate.

We covered this in detail in Part 8, but here in the context of the full architecture, I will add one thing. The weather system appears to be an independent variable, but it is actually connected to the memory system. The shared_umbrella event can only occur when it rains, and this flag later affects ending direction. In other words, a coincidence called weather creates a memory, and that memory changes the outcome. The fact that an element outside the player's control subtly shifts the direction of the relationship — in this way, it resembles real relationships.

Choice Design Principles

Light choices: engagement (everyday)
Medium choices: direction (subtle shifts in the relationship)
Heavy choices: decisions (irreversible)

Choices without right answers > choices with right answers
Emotional judgment > strategic judgment

AI Collaboration Principles

To AI: structure design, variable organization, consistency verification, code drafts, pattern presentation
To humans: emotional weight judgment, nuance adjustment, cliche filtering, final decisions

Request ingredients, not finished products
Carve with questions
Append "why?" to AI's answers

The Experience This Design Aims to Create

Ultimately, there are three experiences this visual novel wants to give the player.

First, "What if I had done it differently." Regret over choices. This is an experience unique to visual novels that other media cannot provide.

Second, "Ah, I liked this person." The experience of love arriving not as a number but as a realization. Conditions accumulate until, at some point, you become aware.

Third, "Am I making this same mistake?" The experience of in-game relationships prompting reflection on real relationships. The self-awareness that what you thought was consideration might have been avoidance.

When all three operate simultaneously, this visual novel becomes not a simple romance simulation but an experience about relationships.

After completing this architecture, I asked the AI "What is the weakest link in this system?" The AI's answer was "The complexity of interactions between variables." The emotion system has 14 variables, the context system has 5, and there are dozens of memory flags. When all of these operate simultaneously, unpredictable combinations can emerge. So the AI and I established "priority rules." For key scenes, emotion variables take highest priority; for everyday scenes, context takes highest priority; for ending branches, memory flags take highest priority. With these situation-specific priorities defined, when variable conflicts arise, it becomes clear which system wins.

The next part is the last. What it means to design scenarios with AI. And where we go from here.

---

Next: What It Means to Design Scenarios with AI — Retrospective and Next Steps