Representation of time

Establishing a model of time is a fundamental aspect of game design and greatly influences the overall game experience. A proper time model provides enough granularity to implement all of the game’s mechanics without edge cases and speculation (and hopefully no exploits) without incurring unnecessary complexity.

Applying a model

Different models can be used for different parts of the game, for example:

  • During the main play loop of a multiplayer card game
  • During exploration in a RPG/strategy game
  • During combat of a RPG/strategy/FPS game
  • During the “combat” of chess or other board games (This is using a very loose definition of combat.)

Models can be nested inside other models:

  • Magic: The Gathering uses a fairly simple turn-based model for players taking their turns, but each player turn is a complex phased model, of which one is the combat phase, which itself contains yet another set of phases.
  • Baseball is organized into nine innings (rounds) where the home team and away team each take one turn at batting (with the other team fielding). Within each half-inning, batters get to take turns batting (an at-bat) until three outs are called, and each at-bat consists of a series of pitches until the batter either strikes out, gets a hit, or is walked. If the batter hits then the game switches into continuous time.

Also, viewpoint matters when applying a model. Chess, for example, can be analyzed as combat in at least two ways:

  • Combat is between two pieces. An attacking piece immediately captures an attacked piece, thus demonstrating an instataneous model of time.
  • Combat is between two players. They take turns moving pieces, capturing an enemy piece if possible, thus demonstrating a turn-based model of time.

Model vs. Presentation

Design decisions

  • How does the game model or represent time? What experience do you want to emphasize?
  • Does this model match the presentation of time to the player, or is it presented differently?
  • What is the time relationship between player issuing commands and characters performing the actions?
  • Are actions resolved independantly or simultaneously? If independantly, which character acts first? If simultaneously, what happens when two conflicting actions must resolve at the same time?
  • How does the game prevent characters from taking an infinite number of actions in a finite amount of time?
  • Does time pause for the player, or relentlessly continue?
  • What effects to these decisions have on gameplay and the player’s perception about the game?

Categories

Instantaneous

The game doesn’t use any significant representation of time during combat; it simply resolves in an outcome which is presented to the player. Thus, what in real life would be a large-scale battle between huge armies is decided in seconds (depending on the capabilities of the computation…) instead of hours or days. We have no idea how the game calculates the result.

Examples

In checkers or chess, the attacking piece immediately captures the attacked piece.

In poker, the player with the best hand wins, with ties splitting the pot.

As mentioned, battles involving large armies are often depicted very abstractly (both in space and time) and reduced to a final result for the player.

Some games have a special “quick battle” option that will immediately resolve what would otherwise be long, tedious battle for the player. The tradeoff is that the AI is usually not as skilled at commanding the player’s units and will incur more cost (lost units/hit points/injuries etc.) even in case of an overall victory.

Phased

Time is modeled as a finite sequence of steps, usually with specifc rules for each step.

Examples: Magic the Gathering - although the game is fundamentally a multi-player turn-based card game, combat is a relatively simple phase-based sequence. (If the word ‘simple’ can be applied to anything in MtG.) Units which survive to the end of turn are healed of all damage.

Discrete (a.k.a Turn-Based)

The game divides time into repeated “chunks” of some finite size. Games with this design are often described as “turn-based” because units “take turns” when acting, instead of acting in parallel. This category breaks down based on two characteristics:

  • Can turn length be measured? If unmeasurable, then turns cannot be compared to each other for length, i.e. one turn cannot be longer or shorter than another. The best that can be said is that all turns are of equal length. (This is similar to stating that all cars have a mass of one car, and therefore they all have equal mass.) If measurable, then turns can be compared for length and determined to be longer or shorter than another, although we may not be able to say by how much.
  • Is there a clock that provides a time base with which to measure time independantly of turns?

Also, the model can be player-centric or character-centric:

  • player-centric: The players are taking turns giving orders to character(s). Some characters may not get an action on the player’s turn, some may get multiple actions.
  • character-centric: The characters are taking turns executing commands given to them by their player. Each character gets one action (barring haste and extra action effects).

Cycle-Based 🔗 (unmeasurable, unclocked)

Time is modeled as a sequence of indistinguishable chunks called turns, where each actor gets to take (typically) one turn in an order established by turn order, and then the cycle repeats.

Round-Based 🔗 (unmeasurable, clocked)

Time is modeled as a sequence of indistinguishable chunks called rounds which contain multiple turns. Each actor gets to take (typically) one turn per round, but since all turns are synchronized to the start of a round either a turn order must be established or all actions must resolve simultaneously. The model also supports effects that trigger at the start or end of a round, and measuring time in terms of rounds.

Queue-Based 🔗 (measurable, unclocked)

Time is modeled as a sequence of variable-sized chunks called turns. Each actor’s turn can now vary in length, causing the timelines to drift out of sync and establish a turn order. Time will be measured or described in turns, but these are turns as experienced by each actor. (Three turns from actor A’s point of view might be more or less time than three turns from actor B’s point of view.)

Clocked Queue-Based 🔗 (measurable, clocked)

Similar to Queue-Based but with the introduction of a clock. Turns now last a specific amount of time described in ticks, and will occasionally synchronize to the tick, again requiring either initiative or simultaneous resolution.

Continuous 🔗 (a.k.a Real-Time, a.k.a Real Life)

Time is modeled as a continuous, unbroken flow. Units act concurrently. Time will be measured or described in seconds, or some other unit based on seconds.

Examples include RPGs like Dungeon Master, Ultima Underworld, the main Elder Scrolls games, Dragon Age: Origins, FPSs like Doom, and MMOs like World of Warcraft.

Hard to categorize

  • Final Fantasy’s Active Time Battle (FF4) - is this discrete, or continuous?
  • Infinity Engine games using turn-based combat that is presented to the user as real-time combat (Baldur’s Gate, Icewind Dale, Planescape: Torment)