The Art of Delaying Consequences — The Memory System
The emotion system (three layers), the context system (scene conditions). We built two. The third and final core system remains. The memory system.
One of the problems with traditional visual novels is that "results are immediate." Make a good choice and you get an instant positive reaction; make a bad choice and you get an instant negative reaction. This turns choices into a quiz.
In real relationships, the results of a choice do not come immediately. Something you said today can come back a month later. An act you thought was considerate can later be interpreted as hurtful. This "delay" is what gives a relationship its weight.
Accumulating Flags
The basic unit of the memory system is the flag. Variables that record the player's choices.
default flags = {
"did_not_ask": 0, # Times you didn't ask at a crucial moment
"avoided_confession": 0, # Times you postponed a confession
"missed_timing": 0, # Times you missed the timing
"protected_but_lied": 0, # Times you lied to protect someone
"shared_umbrella": False, # Whether you ever shared an umbrella
"saw_with_rival": False, # Whether you saw them with a rival
"broke_promise": False # Whether you ever broke a promise
}
Here is the key point. We track not a single instance but a pattern. If did_not_ask is 1, you missed once. If it is 3, it is a pattern. "This person never asks at important moments."
Deferred Outcomes: Choose Now, Face the Results Later
The core technique of this system is the "deferred outcome."
Early on, the player makes a choice.
"I won't ask right now."
In the moment, it looks like consideration. They seem to be having a hard time, so better not to pry. It feels like a mature choice.
In the middle section, the relationship holds. Nothing seems wrong.
In the late section, the character says:
"You never asked anything at the moments that mattered."
This single line cuts the player. What I thought was consideration was felt as indifference by the other person. And it was not a one-time thing — it was a pattern repeated over and over.
What you chose now changes its meaning later. That is the essence of the memory system.
When Good Choices Become Tragedy
We dug into this pattern intensively with AI. The structure that hurts the player most is not "punishing a bad choice" but "turning what looked like a good choice into a tragedy."
We organized several patterns.
The Paradox of Consideration — You choose "You don't have to push yourself to talk about it." It looks like consideration. But when it accumulates, it becomes "You never really saw me."
The Paradox of Protection — You lie to protect someone. It comes from good intentions. But when the truth surfaces later, it becomes "Why didn't you trust me?" The wound is not about the content of the lie but the absence of trust.
The Paradox of Respect — You let them go, telling yourself you are respecting their decision. It looks mature. But what they wanted was for you to hold on. "You said you respected me, but really you were just avoiding the situation."
All three of these look like good choices on the surface. But in the context of a relationship, they are devastating. And the player realizes this only much later. The emotion at that point is not simple sadness — it is regret over one's own judgment. "I was wrong."
Something the AI said while organizing this was striking. "To make the player feel sadness, do not punish a bad choice — turn what looked like a good choice into a tragedy." Exactly right.
Reinterpreting Memories
Another function of the memory system is the reinterpretation of past scenes.
A scene you saw early on takes on a completely different meaning once new information is added later.
For example, a scene early on where the character said, "I'm fine, it's nothing." At the time, you moved on. Later, you learn that in that moment the character was actually going through something incredibly hard. You should have gone back and asked, "Are you okay?" But it is already too late.
Implementing this requires more than a simple flag check — it requires a structure that shows the same scene again in a different context. Techniques like flashback scenes or reconstructions from the other character's perspective.
if flags["did_not_ask"] >= 2 and story_phase == "late":
# Flashback to a past scene — this time from their perspective
jump flashback_their_perspective
Integrating the Three Systems
Now the three systems are in place.
- Emotion System — Tracks the character's inner state (three layers)
- Context System — Tracks scene conditions (location, time, weather, mood)
- Memory System — Accumulates choices and delivers deferred outcomes
Actual scenes open through a combination of all three.
When the emotional state meets certain conditions, the scene context is right, and past flags have accumulated — a specific event fires. Because all three operate simultaneously, different players experience completely different scenes at the same point in the story.
This is complex. But that complexity is why "the relationship feels real." Real relationships, too, move through a combination of emotion, circumstance, and memory.
When I asked the AI about the management complexity of this system, it said, "Having a person manage every combination manually is close to impossible, but if you build just the 20 to 30 key scenes with this structure and handle the rest with simple branching, it becomes realistic." A sound judgment. Applying a triple condition to every scene is overengineering. Apply this structure only to the scenes that matter emotionally.
The Weight That Memory Creates
The most interesting concept that emerged while designing this system was the weight of memory.
The same event carries a different weight depending on whether something similar has happened before. Breaking a promise for the first time can be a mistake. The second time, it becomes a pattern. The third time, it becomes character.
Expressed as a system, this means the same event produces a different magnitude of emotional change depending on flag accumulation.
def apply_broken_promise():
flags["broke_promise"] += 1
count = flags["broke_promise"]
if count == 1:
rel["trust"] -= 5 # A mistake
elif count == 2:
rel["trust"] -= 10 # A pattern
rel["resentment"] += 5
else:
rel["trust"] -= 20 # Character
rel["resentment"] += 10
The first time: "That can happen." The second time: "Again?" The third time: "This is just who they are." As the same behavior repeats, the interpretation shifts, and the magnitude of the emotion changes.
This is exactly how it works in real relationships, too. A single mistake can be forgiven, but a pattern of mistakes changes the nature of the relationship. When this principle is built into the system, choices acquire real weight.
In the next part, we will create the characters who will live atop this system. How to design complex characters whose actions and inner selves diverge.
Next: How to Create Characters Whose Actions and Inner Selves Diverge
댓글
댓글 쓰기