Dead REckoning

• 

• 

• 

• 

• 

Inspiration

Most zombie games are built around one simple idea: survive the next wave.

We wanted to turn failure itself into part of the gameplay.

The idea behind DEAD//RECKONING came from a simple question:

What if dying didn't mean losing your progress — what if your death became your next weapon?

That led us to the concept of Remnants: playable echoes of the player's previous runs. Every failed attempt leaves behind a record of how the player moved, fought, and survived. In the next run, that past version can return and fight alongside the player.

Instead of simply fighting an endless zombie horde, the player is gradually fighting alongside the history of their own decisions.

What We Built

DEAD//RECKONING is a 3D zombie survival shooter centered around its Remnant system.

During a run, the game records important player actions such as movement, aiming, shooting, weapon changes, and other combat events.

When the player dies, the run is preserved as a Remnant.

On a future attempt, that Remnant can replay its recorded behavior in the same environment.

This creates situations where a previous failure can become strategically useful.

For example, a player might accidentally attract a large group of zombies toward one area before dying. On the next run, their Remnant can repeat that behavior, allowing the current player to use the horde's attention as a distraction and escape through another route.

The player's own history therefore becomes part of the level.

How We Built It

The game is built as a browser-based 3D experience using WebGL-compatible technologies.

The main systems include:

• 3D player movement and third-person camera
• Real-time shooting and weapon systems
• Multiple zombie enemy behaviors
• Wave-based survival gameplay
• Deterministic Remnant recording and replay
• Combat feedback and particle effects
• Dynamic lighting and atmospheric effects
• Audio and environmental ambience
• Upgrade and progression systems
• Local gameplay statistics and persistence

The Remnant system was the most important technical component. Instead of relying on a normal AI companion, the game records a timeline of the player's actual actions and reconstructs that behavior during later runs.

This allows every player's Remnants to be based on their own gameplay.

Challenges

The biggest challenge was making the Remnant system reliable while keeping the game responsive.

A recorded run has to be replayed consistently while the player, zombies, projectiles, collisions, and environmental systems are all active at the same time.

We also had to balance visual quality with browser performance. Real-time lighting, particles, enemies, weather, and combat effects can become expensive quickly, so we focused on a compact environment and concentrated the visual detail where it matters most.

Another challenge was making the mechanic understandable without forcing the player through a long tutorial.

The goal was for players to naturally experience the moment of:

"Wait... that's me from my previous run."

What We Learned

Building DEAD//RECKONING taught us that a strong game mechanic is more valuable than simply adding more content.

We learned how recording and replay systems can turn player behavior into game content, how deterministic gameplay helps reproduce previous actions reliably, and how visual and audio feedback can make a technically complex system immediately understandable.

We also learned to design around constraints. Instead of trying to build a massive open-world zombie game, we focused on a smaller environment where combat, atmosphere, and the Remnant mechanic could receive much more attention.

Why It Is Different

The zombie apocalypse is only the setting.

The real game is about the player's history.

Every death leaves something behind.

Every mistake can become useful.

And every new run changes the battlefield because of what the player did before.

In DEAD//RECKONING, your past isn't just remembered. It fights beside you.

Built With

• css
• html
• javascript
• three.js
• vite
• web-audio-api
• webgl