[−][src]Crate game_time

Time handling for games and other real-time simulations.

Provides types and helpers for dealing with time in games. game_time allows for easy decoupling of internal "game" time and external "wall" time, as well as tracking frame rate.

Additionally, different kinds of time steps may be used, while also setting a multiplier for speeding up/slowing down game time progression.

Usage

Put this in your Cargo.toml:

[dependencies]
game_time = "0.2.0"

Overview

game_time consists of 4 main types.

GameClock provides the basic time keeping for a simulation, tracking frames and returning a GameTime at the beginning of each.
GameTime provides the time information for each frame.
FrameCount objects can be optionally used to track frame rate and other runtime statistics, utilizing swappable methods for computing the average fps.
FrameRunner combines a GameClock and FrameCount and makes it easy to run the simulation at a given frame rate.

For each frame, a TimeStep is passed to GameClock in order to advance the frame. This allows the frame rate to be changed at any time, and allows different kinds of time steps (fixed, variable and a constant step are supported by default) to be used based on what is most useful. Together, these objects combine to form a convenient but flexible framework for time progression.

Examples

Run a simulation with 50ms frames, without fps counting:

use game_time::GameClock;
use game_time::step;
use game_time::FloatDuration;

let mut clock = GameClock::new();
let end_time = FloatDuration::seconds(10.0);
let mut sim_time = clock.last_frame_time().clone();
let step = step::ConstantStep::new(FloatDuration::milliseconds(50.0));

while sim_time.total_game_time() < end_time {
    sim_time = clock.tick(&step);
    println!("Frame #{} at time={:?}", sim_time.frame_number(), sim_time.total_game_time());
}

Run a simulation at 30fps, sleeping if necessary to maintain the framerate:

use game_time::{GameClock, FrameCounter, FrameCount, FloatDuration};
use game_time::framerate::RunningAverageSampler;
use game_time::step;

let mut clock = GameClock::new();
let mut counter = FrameCounter::new(30.0, RunningAverageSampler::with_max_samples(60));
let end_time = FloatDuration::seconds(10.0);
let mut sim_time = clock.last_frame_time().clone();

while sim_time.total_game_time() < end_time {
    sim_time = clock.tick(&step::FixedStep::new(&counter));
    counter.tick(&sim_time);
    println!("Frame #{} at time={:?}", sim_time.frame_number(), sim_time.total_game_time());
}

Re-exports

pub use self::clock::GameTime;

pub use self::clock::GameClock;

pub use self::framerate::FrameCounter;

pub use self::framerate::FrameCount;

pub use self::framerate::FrameRateSampler;

pub use self::runner::FrameRunner;

pub use self::step::TimeStep;

Modules

clock	Types for counting and recording time in a simulation.
framerate	Utilities for frame rate computation and management.
runner	Implements the `FrameRunner` struct for managing frame simulations.
step	Types for computing game time from wall time.

Structs

FloatDuration

A time duration stored as a floating point quantity.