Timer Resource/Component

crates/bevy_core/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2018"
 
 [dependencies]
 bevy_app = { path = "../bevy_app" }
+bevy_property = { path = "../bevy_property" }
 bevy_type_registry = { path = "../bevy_type_registry" }
 bevy_transform = { path = "../bevy_transform" }
 legion = { path = "../bevy_legion" }

crates/bevy_core/src/lib.rs

@@ -12,7 +12,7 @@ use bevy_transform::{
 };
 use glam::{Mat3, Mat4, Quat, Vec2, Vec3};
 use legion::prelude::IntoSystem;
-use time::{timer_system, Time};
+use time::{time_system, Time, Timer, timer_system};
 
 #[derive(Default)]
 pub struct CorePlugin;
@@ -31,11 +31,13 @@ impl AppPlugin for CorePlugin {
             .register_component::<Rotation>()
             .register_component::<Scale>()
             .register_component::<NonUniformScale>()
+            .register_component::<Timer>()
             .register_property_type::<Vec2>()
             .register_property_type::<Vec3>()
             .register_property_type::<Mat3>()
             .register_property_type::<Mat4>()
             .register_property_type::<Quat>()
+            .add_system_to_stage(stage::FIRST, time_system.system())
             .add_system_to_stage(stage::FIRST, timer_system.system());
     }
 }

crates/bevy_core/src/time/mod.rs

@@ -0,0 +1,5 @@
+mod time;
+mod timer;
+
+pub use time::*;
+pub use timer::*;

crates/bevy_core/src/time/time.rs

@@ -29,12 +29,12 @@ impl Time {
         if let Some(instant) = self.instant {
             self.delta = now - instant;
             self.delta_seconds_f64 =
-                self.delta.as_secs() as f64 + (self.delta.subsec_nanos() as f64 / 1.0e9);
-            self.delta_seconds = self.delta_seconds_f64 as f32;
+                self.delta.as_secs_f64();
+            self.delta_seconds = self.delta.as_secs_f32();
         }
 
         let duration_since_startup = now - self.startup;
-        self.seconds_since_startup = duration_since_startup.as_secs() as f64 + (duration_since_startup.subsec_nanos() as f64 / 1.0e9);
+        self.seconds_since_startup = duration_since_startup.as_secs_f64();
         self.instant = Some(now);
     }
 
@@ -43,6 +43,6 @@ impl Time {
     }
 }
 
-pub fn timer_system(mut time: ResMut<Time>) {
+pub fn time_system(mut time: ResMut<Time>) {
     time.update();
 }

crates/bevy_core/src/time/timer.rs

@@ -0,0 +1,42 @@
+use std::time::Duration;
+use bevy_property::Properties;
+use legion::prelude::{Res, ComMut};
+use crate::time::Time;
+
+#[derive(Clone, Debug, Default, Properties)]
+pub struct Timer {
+    pub elapsed: f32,
+    pub duration: f32,
+    pub finished: bool,
+}
+
+impl Timer {
+    pub fn from_seconds(seconds: f32) -> Self {
+        Timer {
+            duration: seconds,
+            ..Default::default()
+        }
+    }
+    pub fn new(duration: Duration) -> Self {
+        Timer {
+            duration: duration.as_secs_f32(),
+            ..Default::default()
+        }
+    }
+
+    pub fn tick(&mut self, delta: f32) {
+        self.elapsed = (self.elapsed + delta).min(self.duration);
+        if self.elapsed >= self.duration {
+            self.finished = true;
+        }
+    }
+
+    pub fn reset(&mut self) {
+        self.finished = false;
+        self.elapsed = 0.0;
+    }
+}
+
+pub fn timer_system(time: Res<Time>, mut timer: ComMut<Timer>) {
+    timer.tick(time.delta_seconds);
+}

crates/bevy_diagnostic/src/print_diagnostics_plugin.rs

@@ -1,6 +1,6 @@
 use super::{Diagnostic, DiagnosticId, Diagnostics};
 use bevy_app::{stage, AppPlugin};
-use bevy_core::time::Time;
+use bevy_core::time::{Timer, Time};
 use legion::prelude::*;
 use std::time::Duration;
 
@@ -11,8 +11,7 @@ pub struct PrintDiagnosticsPlugin {
 }
 
 pub struct PrintDiagnosticsState {
-    elapsed: f64,
-    wait_seconds: f64,
+    timer: Timer,
     filter: Option<Vec<DiagnosticId>>,
 }
 
@@ -29,8 +28,7 @@ impl Default for PrintDiagnosticsPlugin {
 impl AppPlugin for PrintDiagnosticsPlugin {
     fn build(&self, app: &mut bevy_app::AppBuilder) {
         app.add_resource(PrintDiagnosticsState {
-            elapsed: 0.0,
-            wait_seconds: self.wait_duration.as_secs_f64(),
+            timer: Timer::new(self.wait_duration),
             filter: self.filter.clone(),
         });
 
@@ -69,9 +67,8 @@ impl PrintDiagnosticsPlugin {
         time: Res<Time>,
         diagnostics: Res<Diagnostics>,
     ) {
-        state.elapsed += time.delta_seconds_f64;
-        if state.elapsed >= state.wait_seconds {
-            state.elapsed = 0.0;
+        state.timer.tick(time.delta_seconds);
+        if state.timer.finished {
             println!("Diagnostics:");
             println!("{}", "-".repeat(60));
             if let Some(ref filter) = state.filter {
@@ -83,6 +80,8 @@ impl PrintDiagnosticsPlugin {
                     Self::print_diagnostic(diagnostic);
                 }
             }
+
+            state.timer.reset();
         }
     }
 
@@ -91,9 +90,8 @@ impl PrintDiagnosticsPlugin {
         time: Res<Time>,
         diagnostics: Res<Diagnostics>,
     ) {
-        state.elapsed += time.delta_seconds_f64;
-        if state.elapsed >= state.wait_seconds {
-            state.elapsed = 0.0;
+        state.timer.tick(time.delta_seconds);
+        if state.timer.finished {
             println!("Diagnostics (Debug):");
             println!("{}", "-".repeat(60));
             if let Some(ref filter) = state.filter {
@@ -105,6 +103,8 @@ impl PrintDiagnosticsPlugin {
                     println!("{:#?}\n", diagnostic);
                 }
             }
+
+            state.timer.reset();
         }
     }
 }

examples/2d/sprite_sheet.rs

@@ -1,33 +1,23 @@
-use bevy::{input::system::exit_on_esc_system, prelude::*};
-use bevy_sprite::{SpriteSheet, SpriteSheetSprite};
+use bevy::prelude::*;
 
 fn main() {
     App::build()
-        .init_resource::<State>()
         .add_default_plugins()
         .add_startup_system(setup.system())
-        .init_system(exit_on_esc_system)
         .add_system(animate_sprite_system.system())
         .run();
 }
 
-#[derive(Default)]
-struct State {
-    elapsed: f32,
-}
-
 fn animate_sprite_system(
-    mut state: ResMut<State>,
-    time: Res<Time>,
     sprite_sheets: Res<Assets<SpriteSheet>>,
+    mut timer: ComMut<Timer>,
     mut sprite: ComMut<SpriteSheetSprite>,
     sprite_sheet_handle: Com<Handle<SpriteSheet>>,
 ) {
-    state.elapsed += time.delta_seconds;
-    if state.elapsed > 0.1 {
-        state.elapsed = 0.0;
+    if timer.finished {
         let sprite_sheet = sprite_sheets.get(&sprite_sheet_handle).unwrap();
         sprite.index = ((sprite.index as usize + 1) % sprite_sheet.sprites.len()) as u32;
+        timer.reset();
     }
 }
 
@@ -55,5 +45,6 @@ fn setup(
                 position: Vec3::new(0.0, 0.0, -0.5),
             },
             ..Default::default()
-        });
+        })
+        .add(Timer::from_seconds(0.1));
 }

examples/app/plugin.rs

@@ -26,8 +26,7 @@ impl AppPlugin for PrintMessagePlugin {
     fn build(&self, app: &mut AppBuilder) {
         let state = PrintMessageState {
             message: self.message.clone(),
-            elapsed_time: 0.0,
-            duration: self.wait_duration,
+            timer: Timer::new(self.wait_duration),
         };
         app.add_resource(state)
             .add_system(print_message_system.system());
@@ -36,14 +35,13 @@ impl AppPlugin for PrintMessagePlugin {
 
 struct PrintMessageState {
     message: String,
-    duration: Duration,
-    elapsed_time: f32,
+    timer: Timer,
 }
 
-fn print_message_system(time: Res<Time>, mut state: ResMut<PrintMessageState>) {
-    state.elapsed_time += time.delta_seconds;
-    if state.elapsed_time > state.duration.as_secs_f32() {
+fn print_message_system(mut state: ResMut<PrintMessageState>, time: Res<Time>) {
+    state.timer.tick(time.delta_seconds);
+    if state.timer.finished {
         println!("{}", state.message);
-        state.elapsed_time = 0.0;
+        state.timer.reset();
     }
 }

examples/ecs/event.rs

@@ -15,24 +15,31 @@ struct MyEvent {
     pub message: String,
 }
 
-#[derive(Default)]
 struct EventTriggerState {
-    elapsed: f32,
+    event_timer: Timer,
+}
+
+impl Default for EventTriggerState {
+    fn default() -> Self {
+        EventTriggerState {
+            event_timer: Timer::from_seconds(1.0)
+        }
+    }
 }
 
 // sends MyEvent every second
 fn event_trigger_system(
+    time: Res<Time>,
     mut state: ResMut<EventTriggerState>,
     mut my_events: ResMut<Events<MyEvent>>,
-    time: Res<Time>,
 ) {
-    state.elapsed += time.delta_seconds;
-    if state.elapsed > 1.0 {
+    state.event_timer.tick(time.delta_seconds);
+    if state.event_timer.finished {
         my_events.send(MyEvent {
             message: "MyEvent just happened!".to_string(),
         });
         
-        state.elapsed = 0.0;
+        state.event_timer.reset();
     }
 }
 

src/prelude.rs

@@ -2,7 +2,7 @@
 pub use crate::asset::{AddAsset, AssetEvent, AssetServer, Assets, Handle};
 #[cfg(feature = "core")]
 pub use crate::core::{
-    time::Time,
+    time::{Time, Timer},
     transform::{CommandBufferBuilderSource, WorldBuilder, WorldBuilderSource},
 };
 #[cfg(feature = "derive")]
@@ -33,7 +33,7 @@ pub use crate::render::{
 #[cfg(feature = "scene")]
 pub use crate::scene::{Scene, SceneSpawner};
 #[cfg(feature = "sprite")]
-pub use crate::sprite::{ColorMaterial, Quad, Sprite, entity::{SpriteEntity, SpriteSheetEntity}};
+pub use crate::sprite::{ColorMaterial, Quad, Sprite, entity::{SpriteEntity, SpriteSheetEntity}, SpriteSheet, SpriteSheetSprite};
 #[cfg(feature = "text")]
 pub use crate::text::Font;
 #[cfg(feature = "transform")]