Environmental Storytelling

Summary

Environmental storytelling is the practice of communicating story through the design of space: layout, damage, props, materials, lighting, and sound sources. Rather than pausing play to deliver narrative (as cutscenes do), environmental storytelling works through implication — players infer events, characters, and conflict from evidence as they act in the world. It supports agency, allows players to self-pace their narrative experience, and can be entirely optional while still rewarding exploration.

(Prof Charles, course lecture series, see source-game-ai-lectures)

---

Working vocabulary

Term	Definition
Mood	Immediate emotional atmosphere from lighting, colour, sound, and pacing
Tone	Broader stylistic attitude that remains coherent across the whole game
Diegetic	Exists within the game world (footsteps, character voices, in-world music sources)
Non-diegetic	Exists outside the world, framing it for the player (score, UI sounds)
Legibility	How easily routes, threats, and points of interest can be read during play
Affordance	What the environment suggests the player can do (cover, climb, interact)
Visual hierarchy	What is prioritised using contrast, framing, and motion
Soundscape	Layered ambience, SFX, spatialisation, and music communicating place and activity
Ludonarrative alignment	When play, space, audio, and visuals all support the same narrative meaning

---

Visual design as narrative

Composition and meaning

Composition directs player attention through framing, contrast, scale, and leading lines. A character or object made small within an overwhelming space implies a narrative relationship — they are insignificant, overwhelmed, or alone. Repeated visual motifs create continuity across spaces, helping players mentally connect locations and construct a coherent world history.

Colour and material

Colour palettes communicate tone quickly:

• Desaturated palettes → bleak, worn, depleted
• Warm accent lighting in cold environments → shelter or warmth as reward
• High contrast → danger zones; low contrast → safety

Materials imply culture and history. Polished stone implies status and maintenance; rusted metal implies neglect, conflict, or industrial use. Wear, stains, repairs, and damage communicate that events have occurred here — without any exposition.

Lighting

Lighting is one of the most powerful narrative tools available:

• Dawn light → renewal, possibility
• Harsh overhead light → exposure, vulnerability, interrogation
• Strong contrast → uncertainty (limited visibility raises perceived risk)
• Focused spotlighting → marks story-relevant objects or paths without UI

In Unity, consider using baked lighting for established areas and real-time lighting for dynamic narrative moments (a light turning on, a fire spreading).

Scale and space

Space communicates psychological state:

• Large open spaces → awe, loneliness, insignificance
• Tight spaces → stress, urgency, limited options
• Verticality → progress (upward), decline (downward), escape, dominance

---

Audio as narrative

Diegetic and non-diegetic audio

Type	Examples	Effect
Diegetic	Footsteps, machinery, wind through vents, in-world dialogue	Grounds the player in the physical world
Non-diegetic	Score, stingers, UI sounds, tension beds	Frames emotion and meaning from outside the world

Strong design aligns both layers so the player experiences one coherent tone. Accidental mismatch (a hopeful score over a ruined environment) produces confusion or unintended humour. Intentional mismatch (an upbeat track over a horror scene) is a deliberate subversion that should be used sparingly and purposefully.

Sound as spatial information

Audio communicates location and distance even without visual cues:

• Directionality — which way to turn
• Loudness — relative distance
• Reverb and occlusion — room size; whether something is behind a wall
• Frequency drop — high frequencies attenuate with distance; muffled sounds are far away or obstructed

Sound supports navigation and threat awareness when the player cannot see the source — effective for stealth games and horror.

Music and silence

The same scene can read as heroic, tragic, or suspicious depending on the score. Adaptive music (responding to combat, stealth, discovery, proximity) shapes pacing and emotional stakes dynamically. See interactive-music-techniques for implementation.

Silence is a deliberate tool. Used at the right moment it creates:

• Vulnerability (absence of grounding sound)
• Focus (drawing attention to the scene)
• Anticipation (holding breath before a reveal)

---

Environmental storytelling vs cutscenes

	Environmental storytelling	Cutscenes
Agency	Maintained — player continues acting	Removed — player watches
Pacing	Self-paced by player curiosity	Author-controlled
Clarity	Lower — relies on inference	Higher — explicit delivery
Immersion	Higher — continuous world-space	Interrupted by camera cut
Best for	World history, atmosphere, implication	Key story beats, character moments

The two modes are complementary. Cutscenes deliver story beats that require clarity; environmental storytelling sustains narrative tone continuously during play. For the full range of techniques between watching and doing (scripted sequences with control kept, walk-and-talk, set pieces, emergent narrative) and open-world approaches, see “From watching to doing” in games-vs-film.

---

Player agency and co-construction

Players decide what to examine and how deeply to explore — narrative information is inherently self-paced. They construct meaning by combining partial clues into a plausible explanation. Different players may reach different interpretations: narrative is partly co-authored by the player’s attention and inference.

This is a feature, not a bug. Leaving inferential gaps:

• Invites player investment (“what happened here?“)
• Supports different engagement depths (completionists vs speedrunners)
• Reduces exposition clutter

---

Storytelling through AI behaviour

Environmental storytelling is not only props and lighting. The characters who live in a space are part of its evidence. What guards protect, how townspeople spend their evening, what enemies say to one another and how they react to traces the player leaves all let the player infer story without dialogue or cutscenes.

Evidence

• People, not obstacles. Smith and Worch quote Steve Powers (Disney): “What changes Guard_03 from an abstract obstacle into a person?” Answering questions such as “What does the innkeeper do with his free time?” turns the game space into a coherent world. Their systemic section adds that “guards walking patrol routes texting with their cell phones implies a lot about their AI state”, and that AI characters can reflect the player’s influence over the environment, citing Far Cry 2 (Smith and Worch, What Happened Here? Environmental Storytelling, GDC 2010).
• Ambient life as authored scenes. De Sevin, Chopinaud and Mars describe Smart Zones: authored areas that each hold a Living Scene. Each zone sets the roles to cast (waiter, client, merchant), the behaviours for each role, their sequence, the triggers and the site. Triggers can be a time of day, the presence of an NPC or the player, or an interaction with an object. In their restaurant example, a waiter only serves when another character is present and it is after 8 pm. In their shopping street, a juggler performs every two hours. The aim is a “feeling of life” that makes sense in the current setting, story and player actions (de Sevin, Chopinaud and Mars, “Smart Zones to Create the Ambience of Life”, Game AI Pro 2, see source-game-ai-pro-2 and smart-zones). The technique comes from MASA Group’s work in Unity, not from a Ubisoft tool, as it is sometimes remembered.
• Barks and squad dialogue. Orkin’s principle for F.E.A.R. was “If the AI didn’t say it, it didn’t happen.” Instead of one enemy barking, several carry on a short dialogue that “broadcasts mental state and intentions to the player”. For example, “What’s your status?” is answered by “I’m hit!”, which tells the player they landed a shot and hints at the enemy’s health. Dialogue can also explain inaction (“Get out of there!” “I’ve got nowhere to go!”) and can even suggest behaviour that was never implemented (Orkin, “The Illusion of Communication”, Game AI Pro 2, see source-game-ai-pro-2).
• Reacting to the player’s traces. In Splinter Cell: Blacklist, an NPC who finds a door the player left open stops, looks around the doorway and asks, “Did I leave that door open?”, then sweeps the room. Walsh notes that the more specific a line is, the more it breaks immersion when repeated. The team therefore used three tiers of barks: specific lines first, then generic ones (“Did I leave that open?”), then neutral ones (“Huh?”) once the player understood the behaviour (Walsh, “Modeling Perception and Awareness in Tom Clancy’s Splinter Cell Blacklist”, Game AI Pro 2, see source-game-ai-pro-2).
• Readable intention. Behaviour only tells a story if the player can read it. Lewis and Dill write that animation “is often the primary language by which the AI communicates its actions, its intentions, and its opinions and feelings to the player”, and that voice work can radically change how believable the AI seems (Lewis and Dill, “Game AI Appreciation, Revisited”, Game AI Pro 2, see source-game-ai-pro-2; see also npc-behaviour-readability).

Techniques

The techniques below apply the evidence above. Where a point is a design inference rather than a claim from a source, it is marked.

Technique	What the player infers	Example
Patrol routes and posts	What the faction values or fears: what is guarded, and what is left unguarded (design inference)	Two guards posted at an empty storeroom suggest it is not empty
Routines and schedules	Who lives here, and what normal life is like before the player disrupts it	A tavern that fills after dark; a market that closes at dusk (Smart Zone triggers)
Barks and overheard dialogue	Squad state, morale and relationships	”Man down!” or “I need reinforcements!” (Orkin)
Reactions to the player’s traces	That the world notices the player; consequences	The open-door reaction in Blacklist; bodies discovered and mourned
Behaviour that changes with history	That events had consequences	Survivors of an earlier attack now patrol in pairs (design inference)
Enemy ecology	How the world works without the player: what creatures eat, where they nest, who hunts whom	Predators sleeping near the remains of their prey (design inference)

In practice (Unity)

• Patrols and posts: waypoint patrols with unity-navmesh, idle “post” behaviours at the end of a route, and per-guard idle animations (smoking, texting, sharpening a blade) chosen to match the place.
• Routines: a time-of-day value that triggers zone scenes, following the smart-zones structure (zone volume, role list, triggers, controller). Behaviour choice can sit in behaviour-trees or ai-state-machine-pattern.
• Barks: a bark is a state-change event plus an audio clip. Tier them so specific lines are heard first and generic ones take over later:

public class TieredBarks : MonoBehaviour
{
    [SerializeField] private AudioSource voice;
    [SerializeField] private AudioClip[] specific; // tier 1: "Did I leave that door open?"
    [SerializeField] private AudioClip[] generic;  // tier 2: "Did I leave that open?"
    [SerializeField] private AudioClip[] neutral;  // tier 3: "Huh?"
 
    // Static so every guard shares one count: the player hears each specific line once.
    private static int timesHeard;
 
    public void BarkOpenDoor()
    {
        AudioClip clip;
        if (timesHeard < specific.Length)
            clip = specific[timesHeard];
        else if (timesHeard < specific.Length + generic.Length)
            clip = generic[timesHeard - specific.Length];
        else
            clip = neutral[Random.Range(0, neutral.Length)];
 
        timesHeard++;
        voice.PlayOneShot(clip);
    }
}

Checks for behavioural storytelling:

• With the HUD hidden, can a playtester say what each NPC group is for?
• Does each important state change (noticed something, searching, alerted, giving up) have an animation or bark that announces it? See npc-behaviour-readability.
• Are specific lines rare and generic lines plentiful, so memorable barks are not repeated?
• Does NPC behaviour agree with what the space says? Relaxed guards in a “fortress under siege” are a ludonarrative mismatch.

Worked example: a character’s past told without text

This is an illustrative design exercise that combines the techniques above; it is not taken from a particular game. Backstory: Maren, a mining-town cook, survived a tunnel collapse that killed her brother. The game never says so. The player should be able to work it out from how she behaves and what she keeps.

Layer	Evidence	Technique
First glance (behaviour at a distance)	Her daily route through the village loops the long way round the old mine entrance	Routine and schedule; unity-navmesh area cost
Reaction (a moment of play)	When blasting rumbles from the new quarry, she stops, drops into a crouch and covers her head, then carries on as if nothing happened	Behaviour that changes with history; readable animation (see npc-behaviour-readability)
Closer look (her space)	Her kitchen has a second place laid at the table that is never used; a child’s drawing of two figures in miners’ helmets is pinned by the stove	Layered clues; props that imply a relationship
Final detail (the why)	In the mine’s memorial alcove, one helmet has fresh wildflowers; the name plate matches the initials carved into her kitchen table	A chain of events the player assembles (Smith and Worch’s “discernible chain of events”)
Echo (later)	If the player clears the collapsed tunnel, her route changes and she visits the alcove openly	World state that answers player choices (see below)

Each layer makes sense alone and better together, which is the layering principle in Designing rewarding discoveries below. Keep the essential reading on the critical path (the route and the flinch are visible to anyone passing) and the explanation off it (the alcove).

In Unity, the avoidance can be a navigation preference rather than a hard wall, so she can go near the mine but chooses not to: give the area around the entrance its own NavMesh area type and raise its cost for her agent only, for example agent.SetAreaCost(NavMesh.GetAreaFromName("OldMine"), 50f);. Call it from OnEnable, because the cost is reset to the default when the agent is disabled and re-enabled (Unity Technologies, Scripting API: NavMeshAgent.SetAreaCost). The flinch is an event from the quarry’s audio cue that calls animator.SetTrigger("Flinch") on villagers within earshot, with a longer, more pronounced animation for Maren than for anyone else. That difference is what tells the player her reaction is personal.

---

Designing rewarding discoveries

Optional story content only works if finding it feels worthwhile. The player should feel they earned an insight, not that they picked up a note.

Evidence

• Space as an information system. Jenkins describes embedded narrative as turning the game world into “a kind of information space, a memory palace”, in the way a detective story tells two stories: the crime and the investigation. Designers “somewhat control the narrational process by distributing the information across the game space”, but “essential narrative information must be redundantly presented across a range of spaces and artifacts”. Players can also “return to a familiar space later in the game and discover it has been transformed” (Jenkins, “Game Design as Narrative Architecture”, see narrative-architecture).
• Practical techniques. Smith and Worch list five: establish a discernible chain of events, ensure the event engages the player, echo the world at large (the premise spawns the events, and the events remind the player of the premise), create characterisation, and minimise disconnects between what the player could do and what is pre-scripted. They suggest authoring scenes as puzzle-like structures, citing Randy Smith’s GDC 2009 talk “Making Your Players Feel Smart”. Their examples include a frozen clock and a water line that together imply a flood, and a whiteboard of survivor messages in Left 4 Dead. They also recommend circular spaces and systems that “look back” at earlier areas, so players can revisit and re-read places (Smith and Worch, What Happened Here? Environmental Storytelling, GDC 2010).

Design principles

These principles are interpretation built on the sources above.

1. Keep the critical path self-sufficient and put the rewards off it. Following Jenkins’ redundancy rule, anything the player must know appears in several places on the main route. Optional discoveries sit just off it: behind a breakable wall, up a side ledge, in a room with a lit window. They deepen understanding rather than gating it. Use player-guidance tools (light, framing, landmarks) to hint that something is there.
2. Layer the clues. Give a first glance (the scene reads at a distance: a barricaded door, bodies facing it), a closer look (props and a note supply the who) and a final detail (one object reveals the why). Each layer should make sense alone and better together. This is Smith and Worch’s “discernible chain of events”, spread over approach distance.
3. Make the payoff change something. The strongest discoveries change the player’s understanding, such as recasting an ally or explaining an enemy’s behaviour, or they pay out in play: a door code, a hidden route, an enemy weakness, a shortcut. Lore that pays out mechanically ties discovery into the core loop. See risk-reward for why optional effort needs a proportional reward.
4. Pace the reveal. Apply the course checklist’s build-up → reveal → aftermath to an object as well as a room. Signal that something is here, frame the moment of discovery, then give the player a quiet beat to absorb it before the next threat (course lecture series, see source-game-ai-lectures).
5. Let discoveries echo later. Return the player to an earlier space that has changed, or let a later scene confirm what a clue implied. This rewards the players who noticed without punishing those who did not.
6. Avoid disconnects. A scripted scene must not contradict what the player’s verbs could have prevented. Smith and Worch’s cautionary example is dead NPCs squashed by doors, a situation the designers would not want to create themselves.

In practice (Unity)

An examine interaction makes discovery deliberate. The player looks at an object, presses interact, reads or hears the clue, and the game records it. Keep the clue logic separate from the UI by raising an event (see observer-pattern):

using System.Collections.Generic;
using UnityEngine;
 
public static class StoryFlags
{
    private static readonly HashSet<string> flags = new HashSet<string>();
    public static event System.Action<string> Changed;            // raised when a new flag is set
 
    public static void Set(string id) { if (flags.Add(id)) Changed?.Invoke(id); }
    public static bool Has(string id) => flags.Contains(id);
    public static List<string> Save() => new List<string>(flags);   // copy into your save data
    public static void Load(IEnumerable<string> saved) { flags.Clear(); flags.UnionWith(saved); }
}
 
public class StoryClue : MonoBehaviour
{
    [SerializeField] private string clueId = "foreman-diary";
    [SerializeField, TextArea] private string examineText;
    [SerializeField] private string unlocksFlag = "vault-code-known"; // the payoff
 
    public static event System.Action<string, string> ClueFound;      // id, text
    private bool found;
 
    // Called by the player's interact check (raycast or trigger + key press).
    public void Examine()
    {
        if (found) return;
        found = true;
        ClueFound?.Invoke(clueId, examineText);   // journal and UI listen to this
        if (!string.IsNullOrEmpty(unlocksFlag))
            StoryFlags.Set(unlocksFlag);          // e.g. the vault keypad now accepts the code
    }
}

A keypad or dialogue option then checks StoryFlags.Has("vault-code-known"). That single check is what turns lore into a reward. For saving, write StoryFlags.Save() into your save data and call StoryFlags.Load(...) when a save is restored. Static fields also survive between Play sessions when Unity’s domain reload is disabled, so clear them on load. The Changed event lets other systems react to a new flag, which the next section uses.

Condition-based reveals (any order)

In a non-linear space the player can find clues in any order, so a reveal should not be tied to a place or a fixed point in a script (“when the player enters the control room, play the confession”). Tie it instead to a condition over what the player knows: the reveal fires the moment the condition becomes true, however the player got there. This is a generalisation of the StoryFlags.Has check above (design guidance, building on Jenkins’ point that designers distribute information across the space and cannot control the order it is found in, see narrative-architecture).

// Fires once when ALL required flags hold and NONE of the blocking flags do, whatever order they arrived in.
public class StoryReveal : MonoBehaviour
{
    [SerializeField] private string[] requires = { "read-foreman-diary", "saw-flooded-lift" };
    [SerializeField] private string[] blockedBy = { "foreman-confessed" };
    [SerializeField] private string revealFlag = "knows-lift-was-sabotaged";
    [SerializeField] private UnityEngine.Events.UnityEvent onReveal;  // new bark, dialogue line, journal entry
 
    private void OnEnable()  { StoryFlags.Changed += Check; Check(null); }
    private void OnDisable() { StoryFlags.Changed -= Check; }
 
    private void Check(string _)
    {
        if (StoryFlags.Has(revealFlag)) return;
        foreach (var f in requires)  if (!StoryFlags.Has(f)) return;
        foreach (var f in blockedBy) if (StoryFlags.Has(f))  return;
        StoryFlags.Set(revealFlag);   // remembered, so it fires once and survives a save
        onReveal.Invoke();
    }
}

Reading the diary first and seeing the flooded lift second gives the same reveal as the reverse order; confronting the foreman first suppresses it, because he has already told the player. Because the reveal sets its own flag, it is saved with the others and later content can depend on it.

The scaled-up version: rule databases. Valve’s dialogue system generalises this idea. Elan Ruskin describes it as a database of rules, “each with a list of criteria about the state of the world”; when a character might speak, the game builds a query of key-value facts (“current map is swamp”, the speaker’s health, what has been seen), and the rule whose criteria best match is chosen. Many rules can match, so the system prefers the most specific one, scored simply by “the number of criteria in a rule”, with general rules as fall-backs. When a rule fires it can write facts back to a character’s memory (that a line has been said, or that the character is speaking for a few seconds), which is how conversations and callbacks are built. Valve used it across The Orange Box, Left 4 Dead, Portal and Dota, and Ruskin notes it can drive “things other than character dialog” (Ruskin, Rule Databases for Contextual Dialog and Game Logic, GDC 2012, slides with speaker notes). For a student project, a handful of StoryReveal components is enough; when the number of conditional lines grows into the hundreds, a rule table of this kind keeps them manageable.

Checks for discoveries:

• Can the game be finished and understood without any optional clue? (Redundancy on the critical path.)
• Does each optional clue add a new fact, recast an old one, or pay out in play?
• Is there a visual or audio hint that something is worth examining, without a waypoint?
• Is there a quiet beat after each major reveal?

---

World state that answers player choices

A choice feels consequential when the world looks and behaves differently afterwards, not only when a line of dialogue acknowledges it. Jenkins notes that players can “return to a familiar space later in the game and discover it has been transformed” (Jenkins, “Game Design as Narrative Architecture”, see narrative-architecture); Smith and Worch add that AI characters can reflect the player’s influence over the environment (Smith and Worch, What Happened Here?, GDC 2010). The guidance below is design advice built on those points.

Design principles

1. Store choices as data, not as scene edits. Record each choice as a flag (or a small world-state object with values such as bridgeState = Blown). Everything that changes reads from that one source.
2. Change the world out of sight. Apply the change when an area loads, behind a closed door, or while the player is elsewhere. A wall that rebuilds itself in view breaks immersion; one that is simply different when you return reads as consequence.
3. Make the change visible next time the player passes. Put the evidence on routes the player already uses: rubble where the bridge was, a guard post at the new chokepoint, mourners at a grave. A consequence nobody sees does no narrative work.
4. Keep it plausible within the fiction. Show the cause of the change as well as the result (scorch marks and debris, not just a missing bridge), so it reads as the world reacting rather than as a level swap. This is Smith and Worch’s “minimise disconnects” applied to consequences.
5. Change behaviour as well as props. NPC routes, schedules and barks should agree with the new state: villagers who used the bridge now queue at the ferry, and a guard remarks on the explosion (see smart-zones for schedule-driven scenes).
6. Persist it. The flags go into save data, and every variant reapplies itself from the flags on load, so the world after a reload matches the world before it.

In practice (Unity)

Navigation has to change with the scenery, or NPCs will walk through rubble or over a bridge that is no longer there. In the AI Navigation package (com.unity.ai.navigation), a NavMesh Link’s Activated setting controls whether agents and path queries can use the link, and a NavMesh Obstacle with Carve enabled cuts a hole in the NavMesh so the pathfinder finds another route; Unity recommends carving for obstacles that generally block navigation and plain obstruction for obstacles that are constantly moving (Unity Technologies, AI Navigation 2.0 manual: NavMesh Link, NavMesh Obstacle and About NavMesh obstacles; Scripting API: NavMeshLink).

using Unity.AI.Navigation;   // AI Navigation package (com.unity.ai.navigation)
using UnityEngine;
using UnityEngine.AI;
 
// Applies a story choice to the physical world when the area loads, out of the player's sight.
public class WorldStateVariant : MonoBehaviour
{
    [SerializeField] private string flag = "bridge-blown";
    [SerializeField] private GameObject[] showIfSet;     // rubble, scorch decals, a guard post
    [SerializeField] private GameObject[] showIfNotSet;  // intact bridge, market stall
    [SerializeField] private NavMeshLink crossing;       // agents may path across only while intact
    [SerializeField] private NavMeshObstacle debris;     // carves a hole so agents re-route
 
    private void Start()
    {
        bool set = StoryFlags.Has(flag);
        foreach (var go in showIfSet)    go.SetActive(set);
        foreach (var go in showIfNotSet) go.SetActive(!set);
        if (crossing != null) crossing.activated = !set;
        if (debris != null) { debris.carving = true; debris.enabled = set; }
    }
}

Because WorldStateVariant reads the flags in Start, it reapplies the right state after loading a save as long as StoryFlags.Load(...) runs before the scene’s objects start. To change an area the player is standing in, subscribe to StoryFlags.Changed instead, but trigger the swap only when the affected objects are off-screen (for example when the player passes through a door). For larger branching states, consider separate set-dressing scenes loaded additively per state rather than many toggled objects (a design suggestion, not tested here). For choosing which content to present in response to the player, rather than how to show it, see ai-experience-management.

Checks for choice consequences:

• Can a playtester who made the choice point to physical evidence of it on their next visit?
• Do NPCs path, idle and bark consistently with the new state (no one walking over the missing bridge)?
• Is the cause of each change visible, not just the result?
• Does saving and reloading reproduce exactly the same world?

---

Case studies

Journey (Thatgamecompany)

Minimal text shifts all narrative weight to landscape composition, colour progression, and musical phrasing. The environment evolves across the game, mirroring emotional progression and theme. Technique: landmarks + colour shifts + musical phrasing operate simultaneously as navigation guidance and narrative statement.

Dark Souls (FromSoftware)

Ruins and hostile spatial design imply a fallen world whose history must be inferred. Sparse audio and careful ambience reinforce isolation and ambiguity — certainty is withheld. Technique: environmental evidence + negative space + sparse soundscape sustain inference and tension throughout.

Half-Life 2 (Valve)

World design communicates political oppression through architecture, surveillance infrastructure, and tightly controlled public space. Diegetic channels (broadcasts, alarms, distant conflict) keep the player contextually informed while maintaining control. Technique: diegetic information + oppressive spatial framing delivers story continuously during play.

---

Common pitfalls

Pitfall	Effect	Fix
Clutter	Players cannot tell what matters	Reduce density; apply visual hierarchy
Uniform importance	Narrative cues become noise	Distinguish signal from background
Audio mismatch	Immersion broken; tonal confusion	Align soundscape with visual mood
Poor mixing	Audio fatigue; unclear spatial information	Test in-engine under real play conditions
Static-only design	Looks good in screenshots; fails in motion	Test with movement, camera motion, and stress

---

Evaluation checklist for level builds

Use this checklist when reviewing a level for environmental narrative quality:

• Narrative inference — a player can infer the basic situation without being told
• Audio-visual alignment — mood and tone are intentional and coherent
• Spatial storytelling — routes and reveals support pacing (build-up → reveal → aftermath)
• Readability under pressure — narrative cues survive movement and combat stress
• Diegetic credibility — sound sources and materials make physical sense
• Information economy — details are purposeful; clutter is minimised
• Player agency — curiosity is rewarded without forcing a single interpretation
• Consistency — visual motifs recur across spaces, making the world feel coherent

(Prof Charles, course lecture series)

---

In practice (Unity)

• Lighting: use Unity’s lighting system (baked/mixed/realtime) to establish narrative mood; Emission materials for focused attention-directing light
• Audio: Unity’s AudioSource with 3D spatial blend, reverb zones (AudioReverbZone), and AudioMixer for soundscape layering
• Visual storytelling: mesh degradation (damage decals, aged materials), prop placement, and level geometry sequencing
• Test without UI: temporarily disable all HUD elements and walk the level — if routes and story are readable, the spatial design is working

---

Related

• narrative-design — narrative delivery channels; environmental storytelling as one channel among many
• level-design — spatial design principles, encounter pacing, player guidance
• thematic-coherence — alignment across all systems, including environment → see narrative-design
• interactive-music-techniques — adaptive music systems for environmental narrative
• sound-design-basics — synthesis, soundscape design, spatial audio
• presence-and-immersion — how environmental storytelling supports spatial and narrative presence
• source-game-ai-lectures
• narrative-architecture — Jenkins’ embedded narrative: the world as an information space
• smart-zones — authored ambient-life scenes with roles, schedules and triggers
• npc-behaviour-readability — making NPC intentions legible
• player-guidance — pointing players towards optional discoveries without waypoints
• games-vs-film — the spectrum from cutscene to emergent narrative
• ai-experience-management — choosing which content to present in response to the player
• unity-navmesh — NavMesh setup, links and obstacles
• ludonarrative-dissonance — when play and story say different things
• source-game-ai-pro-2

External references

• Elan Ruskin, Rule Databases for Contextual Dialog and Game Logic (Valve, GDC 2012), slides with speaker notes: https://cdn.fastly.steamstatic.com/apps/valve/2012/GDC2012_Ruskin_Elan_DynamicDialog.pdf
• Unity Technologies, AI Navigation 2.0 manual: NavMesh Link and NavMesh Obstacle: https://docs.unity3d.com/Packages/com.unity.ai.navigation@2.0/manual/NavMeshLink.html