How To Create A Smarter Game Dialogue In Video Games

When players talk about “choice and consequence” in games, they are usually talking about dialogue. Think of games like Mass Effect, Dragon Age, Detroit: Become Human, Disco Elysium, Red Dead Redemption 2, or Baldur’s Gate 3, where NPCs react, companions approve or disapprove, and endings shift based on what you say and do.

Under the hood, though, most of these systems are still built from fairly simple ingredients:

This works, but it is brittle and hyper-local: the game is reacting to isolated switches rather than maintaining a coherent sense of who the player has become over time.

This essay sketches a different approach. Instead of scattering bespoke flags across scripts, we treat the entire playthrough as a stream of structured events feeding into a time-weighted, multi-dimensional narrative state that any system can query. Dialogue, AI, economy, factions, even difficulty can all speak a shared language about who the player is in systemic terms.

The core abstraction: Action–Object–State

Before we can build anything smarter, we need a common vocabulary. Every significant moment in a game — a murder, a mercy, a theft, a donation — involves three things: who did what, to whom. That turns out to be enough structure to build on.

We can model every meaningful interaction as an action applied to an object, producing a state contribution. The formal name for one such event is an Action Event Pipeline (AEP):

For event n: AEP_n = (a_n, o_n, Δs_n)

Instead of every quest designer inventing their own bespoke flags, the whole game emits AEPs into a central system. That system accumulates all those Δs values over time and exposes a snapshot the current player state S(t) that says: given everything that has happened, here is what this player currently is in narrative terms.

Think of it like event sourcing for story. The raw log of AEPs i\aould be the ground truth. High-level labels like “notorious murderer,” “honorable knight,” or “loose cannon” are derived views computed from this log.

Quantifying morality and impact

Now that we have a pipeline, we need to decide what actually goes into the state contribution for any given event.

This is where most existing systems give up and slap a single slider on the problem. We can do better, and it doesn’t even require anything exotic to start.

The idea is to separate what you did from who you did it to, and then combine them.

Object moral value (M_o), where M_o∈[−1,1]

Give each morally relevant character or object a baseline value on a spectrum from –1 (pure antagonist) to +1 (saint-like):

Designers can hand-author these, or tooling can suggest initial values based on tags and NPC descriptions.

Action impact weight (I_a)

Separately, give each type of action a magnitude- how big a moral move is it, independent of direction?

Killing might be 0.9. Stealing might be 0.4. Lying, 0.3. Offering aid, 0.2. Minor small talk, 0.1.

Combining them

When a player acts, multiply the action’s impact by a function of the target’s moral value. A world where “killing evil is good, killing good is evil” might use:

Δm = I_a · (–M_o)

In practice:

The specific combining function is a design surface. A pacifist world could penalize any killing heavily regardless of the target. A grim noir setting might be tolerant of violence but harsh on betrayal. The point is that every event now has a composable, well-defined contribution to the player’s state, rather than an ad-hoc script.

This means the very similar play styles can have more possibilities than it’s possible to easily count; making re- plays have more variance.

The specific function g(⋅) is a design surface: a pacifist world could penalize any killing heavily, or a grim setting could be more tolerant of brutality.

The important part is that every AEP carries a well-defined, composable contribution instead of ad-hoc one-off script logic.

Time-weighted moral history: redemption and decay

Here’s a problem that single-slider systems almost always get wrong: your first hour of play shouldn’t define your last. If a player murders their way through Act 1, then spends Acts 2 and 3 being genuinely heroic, the world should be able to notice that shift. Conversely, a seemingly good character who suddenly starts making dark choices should raise flags and not get a free pass because their old score is high.

The fix is to weight events by recency. Instead of just summing all past Δm values equally, we apply a decay function so that older events contribute less than recent ones.

A natural choice is exponential decay:
w(t, t_n) = λ^(t — t_n)

where:

With λ close to 1, the world has a long memory and history matters a lot. With smaller λ, recent actions dominate and the world is quicker to update its opinion of you.

The current moral score is then a weighted average of all past impacts:

M_player(t) = Σ w(t, t_n) · Δm_n / Σ w(t, t_n)

In practice, it’s useful to maintain two windows simultaneously, a long-memory lifetime score and a short-window recent score. Dialogue and systems can then distinguish between who the player has usually been and who they seem to be becoming lately. That distinction is what unlocks credible redemption arcs, sudden heel-turns, and gradual corruption, without any hard-coded special cases.

From a single slider to a state vector

Even a well-tuned, time-weighted morality score is still just one axis. Real people are more complicated than that- and so are interesting characters. A player can be kind but unreliable, loyal but brutal, lawful yet deeply selfish, or chaotic but fiercely protective of people they care about. A single good–evil slider collapses all of that into a single number, which is part of why most morality systems feel shallow.

The solution is to track the player as a vector of behavioral dimensions, not a single scalar:

S(t) = [morality, honor, loyalty, chaos, mercy, faction_X_reputation, …]

Each component tracks a different axis of identity. Each action–object pair now yields a vector contribution ΔS_n- nudging multiple dimensions at once. Stealing from a temple might hurt your morality and your reputation with a religious faction, but possibly increase your chaos score. Defecting from the thieves’ guild might drop your loyalty score sharply while improving your standing with law-abiding factions.

The time-weighted aggregation works exactly the same way, just applied across every dimension:

S(t) = Σ w(t, t_n) · ΔS_n / Σ w(t, t_n)

The practical payoff, as mentioned before will be that no two players who play differently are likely to end up with the same state vector. Their identity fingerprints will diverge- and systems across the game can react to those differences in principled, consistent ways.

Keeping authoring sane: tools, tags, and personas

At this point a reasonable objection is: specifying the full state contribution vector for every action–object combination sounds like an enormous amount of work. Won’t that explode the authoring burden?

It doesn’t have to, if you structure it correctly. The key insight is that most objects and actions can be described with a small set of semantic tags- things like “values loyalty,” “abhors betrayal,” “holy relic,” “minor theft,” “armed civilian.” Rule-based templates or lightweight learned models can propose default state contributions from those tags, which designers then review, tweak, and lock in. You get predictability and editorial control without hand-crafting a full table from scratch.

For the trickiest cases- novel action–object combinations that weren’t anticipated at authoring time- transformer-based text encoders can embed both the action description and the NPC description into a shared space and estimate a reasonable ΔS. Designers can always override these estimates with hard rules (”killing any child is always maximally penalized, regardless of the model’s output”).

Feeding the state into dialogue

Once the state model exists, dialogue becomes the most immediate consumer. Traditional dialogue trees gate branches on simple conditions- “has item,” “finished quest,” “morality above 50.” A richer state allows conditions that actually say something:

Writers author a handful of variants keyed to broad regions of state space- “trusted ally,” “feared loose cannon,” “distrusted opportunist”- rather than trying to branch for every possible combination. Before selecting a variant, the system maps the continuous state vector into a small scene-specific persona set. A given conversation might only distinguish three or four roles; the system picks the best fit and falls back to a neutral default when nothing special applies.

Beyond dialogue: systemic consequences

Dialogue is the most visible output of a shared narrative state, but it’s far from the only one. Once you have a single authoritative answer to “who is this player right now,” every other system in the game can ask it.

Difficulty can respond diegetically instead of via invisible rubber-banding. Infamous or chaotic players attract more ambushes, bounty hunters, and armed patrols. Respected heroes receive timely backup from guards or allies during tough encounters. The world feels like it’s reacting rather than quietly tweaking numbers behind the scenes.

Economy and access can reflect reputation. Generous, well-regarded characters get better prices and invitations to exclusive markets. Notorious thieves or serial betrayers face inflated prices, restricted stock, or outright refusal.

Faction politics and world state can evolve from the same foundation. Repeated betrayals could trigger a leadership change. Regions might tighten their laws or increase patrols in response to rising chaos. Because all of this draws from the same action–object–state machinery, the world’s reactions feel coherent across systems rather than disconnected.

Production reality: a hybrid model

All this is purely a though experiment, until it’s put to practical use, and genuinely works. Real productions also live under real constraints, cinematics are expensive, well authored character narrations are finite, and hence, a fully procedural narrative is not only seemimgly endless work to get supported by assets, but it can also drift off tone or break character consistency.

As I always say while architecting, the most practical path is a layered hybrid. One can have:

This can allow a title to be played in the contraints that is reasonably expected from a character, while still computing the result of the actions using our new approach. We’d end up defining a scale for non descrete player states at the time of desicion making.

Why this matters

This architecture doesn’t remove the need for writers, neither does it magically generate good stories. My goal is to have a system of reliable outputs, which can be listened to, to get highly accurate data projecting player’s decisions rather than depending on a combination of limited boolean values. This gives the writers the choice of how finely do they want the game world to be reflected with respect to player’s past / current actions.

Long-term behavior also becomes visible across the game. Multi-dimensional identity replaces the karma bar. Because the state is explicitly time-aware, the world can support credible redemption, slow corruption, loyalty, and betrayal arcs without resorting to one-off exceptions written into individual quest scripts.

From the player’s perspective, the promise is simple. When an NPC calls you out, praises you, or clearly fears you, it’s not just because you picked the red option in the last conversation. It’s because the world has been quietly keeping score across everything you’ve done; and it’s finally telling you what it thinks.