a_timer_running_once.md

A Timer Running Once

Sometimes, we need to have an event that occurs after some predefined time. We can use the resource Time introduced before and count the time by ourselves. Or we can use a build-in utility Timer to help us.

In the following example, we create a Circle, and the circle will become larger after three seconds.

We put a Timer in a custom resource named MyTimer.

#[derive(Resource)]
struct MyTimer(Timer);

The Timer is initialized when we insert the resource.

App::new().insert_resource(MyTimer(Timer::from_seconds(3., TimerMode::Once)))

We use the function Timer::from_seconds to set the time for the Timer to count. We also specify TimerMode::Once, so the event will be triggered at most once.

We check if the Timer satisfies its request in every frame update.

fn circle_scales(
    time: Res<Time>,
    mut my_timer: ResMut<MyTimer>,
    mut circles: Query<&mut Transform, With<Handle<ColorMaterial>>>,
) {
    let mut transform = circles.single_mut();

    if my_timer.0.tick(time.delta()).just_finished() {
        *transform = Transform::from_scale((2., 2., 1.).into());
    }
}

This is done by first updating the Timer through its tick method. We pass the delta of the engine time (i.e., the time difference from the last frame update) to the method. Then we see if the Timer is just_finished its counting.

The full code is as follows:

use bevy::{
    app::{App, Startup, Update},
    asset::{Assets, Handle},
    core_pipeline::core_2d::Camera2dBundle,
    ecs::{
        query::With,
        system::{Commands, Query, Res, ResMut, Resource},
    },
    render::mesh::{shape::Circle, Mesh},
    sprite::{ColorMaterial, ColorMesh2dBundle},
    time::{Time, Timer, TimerMode},
    transform::components::Transform,
    utils::default,
    DefaultPlugins,
};

#[derive(Resource)]
struct MyTimer(Timer);

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .insert_resource(MyTimer(Timer::from_seconds(3., TimerMode::Once)))
        .add_systems(Startup, setup)
        .add_systems(Update, circle_scales)
        .run();
}

fn setup(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>) {
    commands.spawn(Camera2dBundle::default());

    commands.spawn(ColorMesh2dBundle {
        mesh: meshes.add(Circle::new(50.).into()).into(),
        ..default()
    });
}

fn circle_scales(
    time: Res<Time>,
    mut my_timer: ResMut<MyTimer>,
    mut circles: Query<&mut Transform, With<Handle<ColorMaterial>>>,
) {
    let mut transform = circles.single_mut();

    if my_timer.0.tick(time.delta()).just_finished() {
        *transform = Transform::from_scale((2., 2., 1.).into());
    }
}

When the app started:

After three seconds:

➡️ Next: A Timer Running Repeatedly

📘 Back: Table of contents