Fear of the Dark​

Amnesia: The Dark Descent is widely credited with revitalizing the survival horror genre by stripping the player of any means of combat. However, the true source of its terror isn't just the monsters; it's the Economy of Light. By making light a finite, dwindling resource, Frictional Games created a constant, underlying layer of stress that defines the entire experience.

The Tinderbox Economy​

In Amnesia, light comes from two sources: tinderboxes (for stationary candles and torches) and oil (for the player's portable lantern). Both are scarce. This creates a compelling risk-reward loop:

• Do I light this candle to maintain my sanity, knowing I might need that tinderbox later?
• Do I keep my lantern on to see the path ahead, or save the oil for when I'm truly lost?

This is Resource-Driven Pacing. The player's progress is dictated not just by their skill at avoiding monsters, but by their ability to manage their supplies. Running out of oil in a dark, monster-infested dungeon isn't just a failure state; it's a terrifying psychological ordeal.

Sanity as a Gameplay Mechanic​

The scarcity of light is directly tied to the Sanity system. Staying in the dark causes the player's vision to distort and their movement to become sluggish. This forces the player out of their comfort zone. You must seek out light, even if that light makes you more visible to the things prowling in the shadows.

Technical Implementation of Darkness​

From a technical standpoint, Amnesia used a very focused lighting model. Shadows weren't just a visual effect; they were a gameplay volume. The game tracks the player's "exposure" to light sources to drive the sanity and stealth systems.

For modern devs, the lesson of Amnesia is that Vulnerability is the strongest weapon. By taking away the player's tools and making their survival dependent on a depleting resource, you create a level of engagement that no amount of jump scares can match. Scarcity isn't just about difficulty; it's about making every choice feel heavy with consequence.

The Texture of Decay​

Horror lives in the details: the peeling wallpaper of an abandoned asylum, the rusted hinges of a cellar door, the moss-covered stone of a graveyard. Hand-authoring these "messy" textures can be incredibly time-consuming. This is why Photogrammetry—the process of creating 3D meshes and textures from photographs—has become a cornerstone of our environment pipeline at Wave0084.

Capturing the Real World​

The process begins with a high-resolution camera and a lot of patience. We look for real-world locations that exhibit the kind of "natural chaos" that is hard to simulate. Using tools like RealityCapture or Metashape, we process hundreds of photos into a high-poly mesh.

For horror, the "imperfections" are what we're after. The way a piece of wood has rotted or the specific pattern of a blood-like stain on concrete. Photogrammetry captures these nuances with a level of fidelity that "clean" procedural textures often lack.

The Game-Ready Pipeline​

A raw photogrammetry scan is millions of polygons—far too heavy for real-time rendering. Our pipeline involves:

1. Retopology: Creating a clean, low-poly version of the scan.
2. Baking: Transferring the high-poly detail onto the low-poly mesh via Normal and Displacement maps.
3. Delighting: This is the most critical step. Photos contain baked-in lighting information. We use tools like Unity's ArtEngine or Adobe Sampler to remove this lighting, resulting in "PBR-ready" Albedo maps that react correctly to our game's dynamic lights.

Integrating with URP​

In Unity's Universal Render Pipeline, these high-fidelity assets shine when combined with Detail Maps and Decals. By layering a photogrammetric "base" with procedural "grime" decals, we can create environments that feel unique and grounded in reality.

Photogrammetry isn't about replacing artists; it's about giving them a more realistic starting point. It allows us to spend less time on the "grunt work" of modeling bricks and more time on the "art" of lighting and atmosphere.

Seeing in the Dark​

Outlast is famous for its "Found Footage" aesthetic, specifically the green-tinted night vision of the player's camcorder. This isn't just a stylistic choice; it's a core gameplay mechanic that fundamentally changes how the player perceives the environment. Let's break down the technical layers that make this effect so iconic.

The Layers of the Effect​

A convincing night vision effect is more than just a green color filter. In Outlast, it's a combination of several post-processing passes:

1. Luminance Boost: The scene is rendered with a very high exposure, blowing out the highlights to simulate how real night vision tubes intensify light.
2. Monochromatic Grading: The entire image is mapped to a specific green-to-black color ramp.
3. Film Grain and Noise: High-frequency digital noise is added to simulate the sensor noise of a camera operating in low light.
4. Vignetting and Distortions: Subtle lens distortion and a heavy vignette create a sense of looking through a viewfinder, increasing the player's feeling of claustrophobia.

The "Eyes" of the Enemy​

One of the most terrifying aspects of Outlast's night vision is how it handles reflections. Enemies' eyes are given a high-intensity emissive material that only appears bright when viewed through the camcorder. This creates the "glow-in-the-dark" look of a predator's eyes, allowing the player to spot threats in pitch-black areas—at the cost of their limited battery life.

Implementation in URP​

To recreate this in Unity, we use a Custom Post-Processing Effect.

• We use a Full Screen Pass in the Render Feature.
• The shader samples the camera texture and applies a Dot(color, float3(0.3, 0.59, 0.11)) to get the grayscale value.
• This value is then used as an index for a Gradient Map (or a 1D Texture Ramp) to apply the green tint.

Outlast proved that by limiting the player's vision through a technical lens, you can make them feel more connected to the world while simultaneously making them feel more vulnerable. The camcorder isn't just a tool; it's the player's only, fragile lifeline.

The Trail of Terror​

Bloody footprints are a staple of horror storytelling. They guide the player, build tension, and tell a silent story of a struggle. However, in a game where both the player and the monsters can leave dynamic trails, managing thousands of decals can quickly become a performance nightmare.

The Problem with Standard Decals​

Unity's standard Decal Projector is powerful but can be expensive when used in high quantities. Each projector is essentially a specialized camera pass. If you have 500 bloody footprints in a hallway, you're looking at a significant hit to your draw calls and GPU fill rate.

The Solution: GPU-Driven Decal Atlasing​

For Lil Sis, we developed a custom decal system that bypasses the standard projectors for small, repetitive details like footprints.

1. The Atlas: We store all our blood variations in a single high-res texture atlas.
2. The Mesh Batcher: Instead of a "Projector," we use a single mesh that is generated on the fly. When a footprint is created, we add its vertices to a Dynamic Mesh. This allows us to render hundreds of footprints in a Single Draw Call.
3. Projector-Less Projection: We use a custom shader that performs the projection logic in the vertex shader. By passing the ground's normal and position data, we can "shrink-wrap" the footprint mesh to the surface.

Fade-out and Memory Management​

To prevent memory leaks, we use a Circular Buffer for our decals. When the buffer is full, the oldest footprint simply fades out and its vertices are repurposed for the newest one.

// In the decal shader
float alpha = smoothstep(_MaxLifetime, _MinLifetime, v.age);
col.a *= alpha;

This system allows us to have rooms covered in blood and footprints without the player ever noticing a dip in performance. It's a perfect example of how "technical tricks" can be used to support "narrative atmosphere."

"Give us a sign."​

When Phasmophobia exploded in popularity, it wasn't just because of its co-op ghost hunting. It was because it broke the barrier between the player and the game world using Voice Recognition. By allowing players to speak directly to the entities—and having those entities respond—Kinetic Games created a level of intimacy and terror that buttons and menus could never achieve.

The Mechanic of Presence​

In most games, the player is a silent observer. In Phasmophobia, your voice is a beacon. The game uses a "speech-to-text" engine (like Windows Speech Recognition or Google Cloud Speech-to-Text) to listen for specific keywords: "Where are you?", "Are you old?", "Show yourself."

This creates a powerful psychological effect. By forcing the player to speak out loud, the game makes them feel more "present" in the haunted space. It's a form of Role-Playing that is enforced by the game's mechanics. When you're whispering in your dark room and the ghost suddenly responds by throwing a plate, the boundary between reality and the game blurs.

Technical Hurdles: Noise and Privacy​

Implementing voice recognition in a horror game comes with significant challenges:

1. Noise Filtering: The system must distinguish between the player's voice and background noise (or the voices of other players in the room).
2. Latency: The response from the ghost must be near-instantaneous for the interaction to feel real.
3. Platform Support: Speech-to-text APIs vary wildly between Windows, consoles, and mobile.

Beyond the Spirit Box​

The true genius of Phasmophobia is that the ghost is always listening, even when you aren't using the Spirit Box. If you scream in panic, the ghost is more likely to hunt you. This turns the player's own fear response into a gameplay disadvantage.

For indie devs, Phasmophobia is a reminder that the most immersive hardware we have is the one we've had all along: the player's own voice. By integrating it into the core loop, you create a unique, personal horror experience that feels alive.

The Ever-Shifting Labyrinth​

Procedural Generation (ProcGen) is often associated with vast open worlds or roguelikes. However, in horror, ProcGen can be a powerful tool for creating a sense of "unreliable reality." If the layout of the haunted house changes every time the player enters, they can never feel truly safe. The challenge is making these procedural layouts feel believable and atmospheric, rather than just a collection of random rooms.

The Constraint-Based Approach​

For Lil Sis's "Dreamscape" sequences, we use a Constraint-Based Layout Generator. Instead of purely random placement, we define a set of architectural rules:

• Bathrooms must be adjacent to bedrooms.
• Hallways must eventually lead to a "hub" area.
• Escape routes must always be at least two rooms away from the spawn point.

We use a Wave Function Collapse (WFC) algorithm modified for 3D space. WFC ensures that every piece placed (a door, a window, a corner) is logically compatible with its neighbors, preventing the "floating doors" and "hallways to nowhere" common in simpler generators.

Procedural Lighting and Atmosphere​

A room is just a box until it's lit. In a procedural system, we can't hand-place every light. We use a Procedural Light Probe system that analyzes the generated room's volume and places light sources based on its "purpose" (e.g., a flickering fluorescent light in a hallway, a single lamp in a bedroom).

public void GenerateRoomLighting(Room room) {
    // Logic to identify key 'mood' points
    // and instantiate light prefabs with randomized flickers.
}

The Uncanny Valley of Architecture​

The goal of procedural horror interiors is to create something that looks "almost" right. By subtly breaking the rules of architecture—making a hallway slightly too long or a door slightly too small—you trigger the "Uncanny Valley" response in the player. They know something is wrong, even if they can't quite put their finger on it. This architectural gaslighting is a unique strength of procedural systems in the horror genre.

The Lens of Vulnerability​

The 1999 film The Blair Witch Project revolutionized horror by introducing the "Found Footage" subgenre. Its impact on video games, particularly the "walking simulator" horror titles of the last decade, cannot be overstated. From Outlast to the Resident Evil 7 VHS tapes, the tropes of found footage have become a fundamental part of the horror dev's toolkit.

The Limited Field of View​

The most immediate impact of the found footage aesthetic is the Restricted Viewport. In cinema, this is the handheld camera; in games, it's the camcorder or the flashlight. By forcing the player to view the world through a literal lens, you limit their situational awareness.

This creates a sense of Enforced Focus. You can only see what the lens is pointed at, making the periphery—where the monsters are—feel infinitely more dangerous. The "shaky cam" effect, when used subtly, also adds a layer of raw, unpolished realism that makes the horror feel more "real" than a perfectly stabilized AAA camera.

Technical Realism: The Post-Processing of "Cheap"​

Paradoxically, it takes a lot of technical work to make a game look "cheap." To achieve the found footage look, we use:

• Lens Distortion: Simulating the curved glass of a cheap camera.
• Color Grading: Mimicking the limited dynamic range and "crushed" blacks of old digital sensors.
• Interlacing and Artifacting: Adding digital "glitches" that trigger during high-tension moments.

Psychological Distance and Proximity​

Found footage creates a strange duality. On one hand, the camera acts as a barrier, providing a sense of "safety" by being an observer. On the other hand, it makes the horror feel more personal and invasive. It's the "it's happening to you" feeling.

In our own work at Wave0084, we use found-footage sequences to tell the "history" of a location. By switching the player's perspective to a low-fidelity, handheld view of a past event, we can build dread for what is waiting for them in the present. The Blair Witch isn't just about a movie; it's about the power of the lens to transform the mundane into the monstrous.

Attacking the Player, Not the Character​

In 2002, Eternal Darkness: Sanity's Requiem introduced "Sanity Effects" that didn't just affect the character—they targeted the player. From "deleting" save files to muting the TV, these meta-scares are legendary. Building a modern equivalent in C# for Unity requires a robust, modular architecture that can handle a wide variety of "hallucinations."

The Sanity Controller​

The core of the system is a centralized SanityManager. This class tracks a normalized value from 0 to 1 and fires events as the player crosses certain thresholds.

public class SanityManager : MonoBehaviour {
    public float Sanity { get; private set; }
    public UnityEvent<SanityLevel> OnSanityTierChanged;

    public void ModifySanity(float amount) {
        Sanity = Mathf.Clamp01(Sanity + amount);
        // Tier checking logic...
    }
}

Modular Hallucinations​

We don't want the SanityManager to know about every possible effect. Instead, we use a Command Pattern or a ScriptableObject-based Effect System.

1. Visual Hallucinations: These are driven by Post-Processing. As sanity drops, we increase the intensity of a "Lens Distortion" or "Color Shift."
2. Auditory Hallucinations: Using our Binaural audio system, we play "phantom sounds" (whispers, footsteps) behind the player that have no physical source in the world.
3. Mechanical Hallucinations: These are the "meta" scares. In Unity, this might involve subtly changing the player's movement speed, reversing their input for a split second, or showing a "fake" loading screen.

The Risk of Frustration​

The golden rule of Sanity Systems is: Never break the game. A sanity effect that causes a real crash or a real loss of progress is a bug, not a feature. The goal is to make the player think the game is breaking.

For Lil Sis, we've refined this by ensuring that all sanity effects are strictly visual or auditory. We want to gaslight the player's senses, not their patience. By building a system where "hallucinations" are just another layer of the rendering and audio stack, we can create a deep, unsettling experience that feels like the world itself is coming apart at the seams.

The Gold Standard of Tactical Terror​

Released in 2005, F.E.A.R. (First Encounter Assault Recon) is still frequently cited as having the best AI in any first-person shooter. Even in 2026, many modern titles struggle to replicate the feeling of fighting a coordinated, intelligent team of enemies. The secret wasn't just complex logic; it was a revolutionary architecture called GOAP (Goal Oriented Action Planning).

What is GOAP?​

Unlike traditional "Finite State Machines" (where an enemy is either in an "Idle," "Search," or "Attack" state), GOAP allows the AI to decide how to achieve a goal based on the current world state.

If an AI's goal is to KillPlayer, it looks at its available actions:

• ShootPlayer (requires weapon, line of sight)
• AdvanceToCover (requires cover nearby)
• FlushPlayerWithGrenade (requires grenade, player in cover)

The AI "plans" a sequence of actions that leads to the goal. This leads to Emergent Behavior. If you suppress an enemy, they don't just "go into cover state." They plan a route to cover while another AI plans a suppressive fire action to cover them.

The Illusion of Communication​

F.E.A.R.'s AI feels intelligent because it "talks." The enemies call out their actions: "Flanking!", "I'm suppressed!", "Grenade out!" From a technical standpoint, this is just the AI broadcasting its current "Action" to the audio system. However, for the player, it creates the illusion of a highly coordinated tactical unit.

Implementation in Modern Engines​

Building a GOAP system in Unity or Unreal is more accessible than ever.

1. The Planner: A simple A* search algorithm that traverses the "Action Space" to find the cheapest path to a goal.
2. The World State: A set of boolean flags (e.g., HasWeapon, PlayerInSight, NearCover) that the AI uses to evaluate its plan.
3. Blackboards: Shared data structures that allow team members to share information about the player's last known position.

The legacy of F.E.A.R. is that great AI isn't about being "hard" to beat; it's about being believable. By giving enemies goals and the tools to achieve them dynamically, you create a game where every encounter feels unique and every enemy feels like a thinking, breathing threat.