Theory vs Practice

I've presented this so far as a very theoretical, esoteric idea, but it's really quite practical.

The explanation of time in Reset Hard is that individual 'frames' of time each contain perfect copies of the world. When a player moves through time what's really happening is that they are sequentially becoming aware of the whatever the next frame is. The world of Reset Hard is entirely deterministic. If a player moves backwards in time, all that they're really doing is shifting their focus to a previous frame.

Representing this in code is thus relatively straightforward. Time is a bounded array. Within each 'frame' of time I store an entire copy of a serialized game state. I don't anything fancy with computing deltas. I don't do anything complicated like rerunning the simulation from a keyframe.

var timeline = {
   length : 30 * 60 * 10, //30 fps 10 minutes
   frames : [{ /*json serialized initial frame */ }],
   waves : [{
       frame: 0,
   }],
};

function update() {
    _.each(waves, function (wave) {
        var world = frames[wave.frame];
        var next_world = world_update(world);
        frames[wave.frame++] = next_world;
    });
}

Levels in Reset Hard are at most maybe 10 minutes in length, and the memory requirements for 10 minutes of 30fps game logic is trivial. If memory does become a problem in the future, or if I just want to make the game more efficient on lower-end computers, I'll switch to a more efficient data compression format for world states. I won't change the implementation to do something clever like add partial world states or record keyboard input.

You'll notice above that I use 'waves' to determine which frames to update and overwrite. These also appear as game mechanics - there are a set of game rules determining when a wave gets created, what it's velocity is, how waves react to colliding with each other, and so on. Again, this is just me exposing how the code works.

"But wait", I hear you asking. "If the world is deterministic, how does the player overwrite the past? Surely there's some kind of implementation trickery going on there."

Not so!

var timeline = {
   length : 30 * 60 * 10,
   frames : [{}],
   waves : [{ frame: 0 }]
};

var meta = {
    player : {
        focus : 0
    }
};

Player controllers exist outside of time. They use the same system to interact with the world that I use internally for puzzles. The player focus determines which frame will be shown to the player; and the player's input is projected onto the focused frame so they can direct their avatar's actions.

This even extends to the physical human sitting in the chair in front of the computer.

How are the players actions transmitted to the game? The player exists in a state that I call 'meta-meta-time.' Their actions are projected via a keyboard and an Operating System into meta-time (the game's global state). This is why no one in the game bats an eye when from their perspective someone new just happens to exist one day. The player exists in meta-meta-time, the player's avatar is projected into meta-time, and then their physical presence is projected from meta-time onto the regular timeline.

Of course at this point I'm starting to stray away from the practical stuff that I was talking about above. But I bring this up as an example of just how far I'm willing to go to avoid hand-waving or hiding narrative inconsistencies with reality. When the story of Reset Hard deviates from the player's physical reality, I alter the story. I don't pretend that reality changed.