Struct bevy::core::Timer

pub struct Timer { /* fields omitted */ }

Tracks elapsed time. Enters the finished state once duration is reached.

Non repeating timers will stop tracking and stay in the finished state until reset. Repeating timers will only be in the finished state on each tick duration is reached or exceeded, and can still be reset at any given point.

Paused timers will not have elapsed time increased.

Implementations

impl Timer

pub fn new(duration: Duration, repeating: bool) -> Timer

Creates a new timer with a given duration.

See also Timer::from_seconds.

pub fn from_seconds(duration: f32, repeating: bool) -> Timer

Creates a new timer with a given duration in seconds.

Example

let mut timer = Timer::from_seconds(1.0, false);

pub fn finished(&self) -> bool

Returns true if the timer has reached its duration.

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, false);
timer.tick(Duration::from_secs_f32(1.5));
assert!(timer.finished());
timer.tick(Duration::from_secs_f32(0.5));
assert!(timer.finished());

pub fn just_finished(&self) -> bool

Returns true only on the tick the timer reached its duration.

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, false);
timer.tick(Duration::from_secs_f32(1.5));
assert!(timer.just_finished());
timer.tick(Duration::from_secs_f32(0.5));
assert!(!timer.just_finished());

pub fn elapsed(&self) -> Duration

Returns the time elapsed on the timer. Guaranteed to be between 0.0 and duration. Will only equal duration when the timer is finished and non repeating.

See also Stopwatch::elapsed.

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, false);
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.elapsed(), Duration::from_secs_f32(0.5));

pub fn elapsed_secs(&self) -> f32

Returns the time elapsed on the timer as a f32. See also Timer::elapsed.

pub fn set_elapsed(&mut self, time: Duration)

Sets the elapsed time of the timer without any other considerations.

See also Stopwatch::set.

use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, false);
timer.set_elapsed(Duration::from_secs(2));
assert_eq!(timer.elapsed(), Duration::from_secs(2));
// the timer is not finished even if the elapsed time is greater than the duration.
assert!(!timer.finished());

pub fn duration(&self) -> Duration

Returns the duration of the timer.

Examples

use std::time::Duration;
let timer = Timer::new(Duration::from_secs(1), false);
assert_eq!(timer.duration(), Duration::from_secs(1));

pub fn set_duration(&mut self, duration: Duration)

Sets the duration of the timer.

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(1.5, false);
timer.set_duration(Duration::from_secs(1));
assert_eq!(timer.duration(), Duration::from_secs(1));

pub fn repeating(&self) -> bool

Returns true if the timer is repeating.

Examples

let mut timer = Timer::from_seconds(1.0, true);
assert!(timer.repeating());

pub fn set_repeating(&mut self, repeating: bool)

Sets whether the timer is repeating or not.

Examples

let mut timer = Timer::from_seconds(1.0, true);
timer.set_repeating(false);
assert!(!timer.repeating());

pub fn tick(&mut self, delta: Duration) -> &Timer

Advance the timer by delta seconds. Non repeating timer will clamp at duration. Repeating timer will wrap around.

See also Stopwatch::tick.

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, false);
let mut repeating = Timer::from_seconds(1.0, true);
timer.tick(Duration::from_secs_f32(1.5));
repeating.tick(Duration::from_secs_f32(1.5));
assert_eq!(timer.elapsed_secs(), 1.0);
assert_eq!(repeating.elapsed_secs(), 0.5);

pub fn pause(&mut self)

Pauses the Timer. Disables the ticking of the timer.

See also Stopwatch::pause.

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, false);
timer.pause();
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.elapsed_secs(), 0.0);

pub fn unpause(&mut self)

Unpauses the Timer. Resumes the ticking of the timer.

See also Stopwatch::unpause().

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, false);
timer.pause();
timer.tick(Duration::from_secs_f32(0.5));
timer.unpause();
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.elapsed_secs(), 0.5);

pub fn paused(&self) -> bool

Returns true if the timer is paused.

See also Stopwatch::paused.

Examples

let mut timer = Timer::from_seconds(1.0, false);
assert!(!timer.paused());
timer.pause();
assert!(timer.paused());
timer.unpause();
assert!(!timer.paused());

pub fn reset(&mut self)

Resets the timer. the reset doesn’t affect the paused state of the timer.

See also Stopwatch::reset.

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, false);
timer.tick(Duration::from_secs_f32(1.5));
timer.reset();
assert!(!timer.finished());
assert!(!timer.just_finished());
assert_eq!(timer.elapsed_secs(), 0.0);

pub fn percent(&self) -> f32

Returns the percentage of the timer elapsed time (goes from 0.0 to 1.0).

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(2.0, false);
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.percent(), 0.25);

pub fn percent_left(&self) -> f32

Returns the percentage of the timer remaining time (goes from 0.0 to 1.0).

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(2.0, false);
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.percent_left(), 0.75);

pub fn times_finished(&self) -> u32

Returns the number of times a repeating timer finished during the last tick call.

For non repeating-timers, this method will only ever return 0 or 1.

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, true);
timer.tick(Duration::from_secs_f32(6.0));
assert_eq!(timer.times_finished(), 6);
timer.tick(Duration::from_secs_f32(2.0));
assert_eq!(timer.times_finished(), 2);
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.times_finished(), 0);

Trait Implementations

impl Clone for Timer

pub fn clone(&self) -> Timer

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for Timer where
    Timer: 'static,
    Timer: Send,
    Timer: Sync, 

type Storage = TableStorage

impl Debug for Timer

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

Formats the value using the given formatter.

impl Default for Timer

pub fn default() -> Timer

Returns the “default value” for a type.

impl GetTypeRegistration for Timer

pub fn get_type_registration() -> TypeRegistration

impl Reflect for Timer

pub fn type_name(&self) -> &str

pub fn any(&self) -> &(dyn Any + 'static)

pub fn any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn reflect_ref(&self) -> ReflectRef<'_>

pub fn reflect_mut(&mut self) -> ReflectMut<'_>

pub fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable value, if serialization is supported. Otherwise None will be returned.

pub fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type) if hashing is supported. Otherwise None will be returned.

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

Returns a “partial equal” comparison result if comparison is supported. Otherwise None will be returned.

impl Struct for Timer

pub fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_at_mut(
    &mut self,
    index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn name_at(&self, index: usize) -> Option<&str>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> FieldIter<'_>

pub fn clone_dynamic(&self) -> DynamicStruct