Struct Time 

pub struct Time { /* private fields */ }

Frame timing and a simple named-event scheduler. Available as ctx.time.

// Fire an event called "spawn" every 2.5 seconds of game time.
ctx.time.every("spawn", 2.5);
// ...later, in update():
if ctx.time.fired("spawn") {
    ctx.speech.speak("A new enemy appears");
}

Implementations

impl Time

pub fn delta(&self) -> f32

Seconds of game time since the previous frame (affected by Time::set_scale).

Multiply speeds by this to make movement frame rate independent: position.x += speed * ctx.time.delta();

Examples found in repository

examples/bell_catcher.rs (line 254)

    fn update(&mut self, ctx: &mut Context) {
        if self.over {
            if ctx.ui.closed("over") {
                ctx.switch_scene(Title);
            }
            return;
        }
        if ctx.pressed(Key::Escape) {
            ctx.switch_scene(Title);
            return;
        }
        if ctx.pressed(Key::S) {
            ctx.speak(format!("{} bells, {} lives", self.score, self.lives));
        }
        for (key, step) in [(Key::Left, -1), (Key::Right, 1)] {
            if ctx.input.repeating(key, 0.3, 0.15) {
                let lane = (self.lane + step).clamp(-LANES, LANES);
                if lane == self.lane {
                    ctx.play("edge");
                } else {
                    self.lane = lane;
                    ctx.audio.sound("step").at(vec3(step as f32 * 0.5, 0.0, 0.0)).random_pitch(0.9, 1.1).play();
                }
            }
        }

        let dt = ctx.time.delta();
        if self.left < 0.0 {
            self.left += dt;
            if self.left >= 0.0 {
                self.drop_bell();
            }
            return;
        }
        self.left -= dt;
        self.next_ring -= dt;
        if self.left <= 0.0 {
            self.land(ctx);
        } else if self.next_ring <= 0.0 {
            self.ring(ctx);
        }
    }

examples/flight.rs (line 89)

    fn update(&mut self, ctx: &mut Context) {
        if ctx.pressed(Key::Escape) {
            ctx.quit();
        }
        if ctx.pressed(Key::Left) || ctx.pressed(Key::Right) {
            let facing = ctx.physics.turn(self.drone, if ctx.pressed(Key::Left) { -30.0 } else { 30.0 });
            ctx.speak(math::direction_name(facing));
        }
        if ctx.pressed(Key::PageUp) || ctx.pressed(Key::PageDown) {
            let pitch = ctx.physics.tilt(self.drone, if ctx.pressed(Key::PageUp) { 30.0 } else { -30.0 });
            ctx.speak(describe_pitch(pitch));
        }

        // Smooth flight: 4 meters per second while a key is held.
        let speed = 4.0 * ctx.time.delta();
        let forward = ctx.input.axis(Key::Down, Key::Up);
        if forward != 0.0 {
            let result = ctx.physics.move_forward(self.drone, forward * speed);
            self.fly(ctx, result);
        }
        let rise = ctx.input.axis(Key::Q, Key::E);
        if rise != 0.0 {
            let result = ctx.physics.move_up(self.drone, rise * speed);
            self.fly(ctx, result);
        }

        if ctx.pressed(Key::C) {
            let position = ctx.physics.position(self.drone);
            match ctx.physics.nearest_with_tag(position, "bird") {
                Some(bird) => {
                    let text = ctx.physics.describe(self.drone, bird); // e.g. "2 o'clock, 9 meters, 6 meters above"
                    ctx.speak(text);
                }
                None => ctx.speak("No birds left"),
            }
        }
        if ctx.pressed(Key::F) {
            let (facing, pitch) = (ctx.physics.facing(self.drone), ctx.physics.pitch(self.drone));
            ctx.speak(format!("Facing {}, {}", math::direction_name(facing), describe_pitch(pitch)));
        }
        if ctx.pressed(Key::H) {
            let height = ctx.physics.position(self.drone).z;
            ctx.speak(format!("{height:.0} meters high"));
        }

        if let Some(bird) = ctx.physics.entered_tag(self.drone, "bird") {
            ctx.physics.remove(bird);
            self.birds -= 1;
            ctx.play("found");
            if self.birds == 0 {
                ctx.ui.message("done", "You found every bird!");
            } else {
                ctx.speak(format!("Bird found! {} left.", self.birds));
            }
        }
        if ctx.ui.closed("done") {
            ctx.quit();
        }
    }

pub fn real_delta(&self) -> f32

Like Time::delta but ignores the time scale. Useful for menus while the game is paused.

pub fn elapsed(&self) -> f64

Seconds of game time since the game started.

Examples found in repository

examples/hello.rs (line 17)

    fn update(&mut self, ctx: &mut Context) {
        if ctx.input.pressed(Key::Space) {
            // A pitch that rises over time, so every beep sounds different.
            let pitch = 300.0 + (ctx.time.elapsed() as f32 * 50.0) % 900.0;
            ctx.audio.play_tone(pitch.round(), 0.15);
        }
        if ctx.input.pressed(Key::F1) {
            ctx.speech.repeat_last();
        }
        if ctx.input.pressed(Key::Escape) {
            ctx.quit();
        }
    }

examples/platformer.rs (line 64)

    fn update(&mut self, ctx: &mut Context) {
        if ctx.pressed(Key::Escape) {
            ctx.quit();
        }

        // The lift goes up for 4 seconds and down for 4 seconds.
        let lift_up = (ctx.time.elapsed() % 8.0) < 4.0;
        ctx.physics.set_velocity(self.lift, vec3(0.0, 0.0, if lift_up { 2.0 } else { -2.0 }));

        let run = ctx.input.axis(Key::Left, Key::Right);
        let mut velocity = ctx.physics.velocity(self.player);
        velocity.x = run * 6.0;
        ctx.physics.set_velocity(self.player, velocity);
        if ctx.pressed(Key::Space) && ctx.physics.jump(self.player, 2.5) {
            ctx.play("jump");
        }
        let running = ctx.physics.on_ground(self.player) && run != 0.0;
        self.run_sound.set_volume(if running { 0.6 } else { 0.0 });

        if let Some(speed) = ctx.physics.landed(self.player) {
            ctx.audio.sound("land").volume((speed / 12.0).clamp(0.2, 1.0)).play();
            if speed > 15.0 {
                ctx.speak("Ouch!");
            }
        }
        if let Some((other, _)) = ctx.physics.collided(self.player)
            && ctx.physics.tag(other) == "crate"
        {
            ctx.play_on(other, "push");
        }
        if let Some(coin) = ctx.physics.entered_tag(self.player, "coin") {
            ctx.physics.remove(coin); // its looping sound stops by itself
            self.score += 1;
            ctx.audio.sound("coin").pitch(1.5).play();
            ctx.speak(format!("{} of {COINS} coins", self.score));
            if self.score == COINS {
                ctx.ui.message("won", "You collected every coin! Press enter to quit.");
            }
        }
        if ctx.ui.closed("won") {
            ctx.quit();
        }

        if ctx.pressed(Key::S) {
            let x = ctx.physics.position(self.player).x;
            ctx.speak(format!("Score {}, position {x:.0}", self.score));
        }
    }

pub fn real_elapsed(&self) -> Duration

Wall clock time since the engine started, ignoring the time scale.

pub fn frame(&self) -> u64

Number of frames since the game started.

pub fn fps(&self) -> f32

Current frames per second (smoothed).

pub fn scale(&self) -> f32

Current time scale. 1.0 is normal speed.

pub fn set_scale(&mut self, scale: f32)

Speeds up (> 1.0), slows down (< 1.0) or pauses (0.0) game time. Physics, the scheduler and Time::delta all follow the scale.

pub fn pause(&mut self)

Pauses game time. Same as set_scale(0.0).

Examples found in repository

examples/beacon.rs (line 138)

    fn start(&mut self, ctx: &mut Context) {
        ctx.time.pause();
        ctx.ui.open(Menu::new("pause", "Paused").button("resume", "Resume").button("quit", "Quit game"));
    }

pub fn resume(&mut self)

Resumes game time at normal speed.

Examples found in repository

examples/beacon.rs (line 153)

    fn end(&mut self, ctx: &mut Context) {
        ctx.time.resume();
    }

pub fn is_paused(&self) -> bool

Whether game time is paused.

pub fn after(&mut self, name: impl Into<String>, seconds: f32)

Schedules a one-shot event named name that fires after seconds of game time. Scheduling a name that is already pending replaces it.

Examples found in repository

examples/clicker.rs (line 15)

fn main() -> audio_code::Result<()> {
    let mut score = 0;

    audio_code::run("Clicker", move |ctx| {
        if ctx.once("intro") {
            let best: u32 = ctx.storage.get_or("best", 0);
            ctx.speak(format!("Press space as often as you can in ten seconds. Your best is {best}. Go!"));
            ctx.time.after("end", 10.0);
        }

        if ctx.time.is_scheduled("end") && ctx.pressed(Key::Space) {
            score += 1;
            ctx.audio.play_tone(300.0 + score as f32 * 15.0, 0.05);
        }

        if ctx.time.fired("end") {
            let best: u32 = ctx.storage.get_or("best", 0);
            if score > best {
                ctx.storage.set("best", score);
                ctx.ui.message("result", format!("{score} presses. New record!"));
            } else {
                ctx.ui.message("result", format!("{score} presses. Your best is {best}."));
            }
        }

        if ctx.ui.closed("result") || ctx.pressed(Key::Escape) {
            ctx.quit();
        }
    })
}

pub fn every(&mut self, name: impl Into<String>, seconds: f32)

Schedules a repeating event named name that fires every seconds of game time. Scheduling a name that is already pending replaces it.

pub fn cancel(&mut self, name: &str)

Cancels a scheduled event. Does nothing if it does not exist.

pub fn is_scheduled(&self, name: &str) -> bool

Whether an event with this name is waiting to fire.

Examples found in repository

examples/clicker.rs (line 18)

fn main() -> audio_code::Result<()> {
    let mut score = 0;

    audio_code::run("Clicker", move |ctx| {
        if ctx.once("intro") {
            let best: u32 = ctx.storage.get_or("best", 0);
            ctx.speak(format!("Press space as often as you can in ten seconds. Your best is {best}. Go!"));
            ctx.time.after("end", 10.0);
        }

        if ctx.time.is_scheduled("end") && ctx.pressed(Key::Space) {
            score += 1;
            ctx.audio.play_tone(300.0 + score as f32 * 15.0, 0.05);
        }

        if ctx.time.fired("end") {
            let best: u32 = ctx.storage.get_or("best", 0);
            if score > best {
                ctx.storage.set("best", score);
                ctx.ui.message("result", format!("{score} presses. New record!"));
            } else {
                ctx.ui.message("result", format!("{score} presses. Your best is {best}."));
            }
        }

        if ctx.ui.closed("result") || ctx.pressed(Key::Escape) {
            ctx.quit();
        }
    })
}

pub fn remaining(&self, name: &str) -> Option<f32>

Seconds until the named event fires, or None if it is not scheduled.

pub fn fired(&self, name: &str) -> bool

Returns true during the frame in which the named event fired.

Examples found in repository

examples/clicker.rs (line 23)

fn main() -> audio_code::Result<()> {
    let mut score = 0;

    audio_code::run("Clicker", move |ctx| {
        if ctx.once("intro") {
            let best: u32 = ctx.storage.get_or("best", 0);
            ctx.speak(format!("Press space as often as you can in ten seconds. Your best is {best}. Go!"));
            ctx.time.after("end", 10.0);
        }

        if ctx.time.is_scheduled("end") && ctx.pressed(Key::Space) {
            score += 1;
            ctx.audio.play_tone(300.0 + score as f32 * 15.0, 0.05);
        }

        if ctx.time.fired("end") {
            let best: u32 = ctx.storage.get_or("best", 0);
            if score > best {
                ctx.storage.set("best", score);
                ctx.ui.message("result", format!("{score} presses. New record!"));
            } else {
                ctx.ui.message("result", format!("{score} presses. Your best is {best}."));
            }
        }

        if ctx.ui.closed("result") || ctx.pressed(Key::Escape) {
            ctx.quit();
        }
    })
}

pub fn fired_events(&self) -> impl Iterator<Item = &str>

All events that fired this frame.

Trait Implementations

impl Debug for Time

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Time

fn default() -> Self

Returns the “default value” for a type.