From 308fa2d0776edab975fbf682746317cd5eeea4f0 Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Thu, 22 Jun 2023 13:49:38 +0000
Subject: [PATCH 01/16] Unify FixedTime and Time (proof-of-concept)

---
 crates/bevy_time/src/fixed_timestep.rs |  9 ++--
 crates/bevy_time/src/time.rs           | 59 ++++++++++++++++++++++++++
 2 files changed, 63 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_time/src/fixed_timestep.rs b/crates/bevy_time/src/fixed_timestep.rs
index 66be2f41ef2ff..9a31e1053dc33 100644
--- a/crates/bevy_time/src/fixed_timestep.rs
+++ b/crates/bevy_time/src/fixed_timestep.rs
@@ -101,17 +101,16 @@ pub enum FixedUpdateError {
 
 /// Ticks the [`FixedTime`] resource then runs the [`FixedUpdate`].
 pub fn run_fixed_update_schedule(world: &mut World) {
-    // Tick the time
-    let delta_time = world.resource::<Time>().delta();
-    let mut fixed_time = world.resource_mut::<FixedTime>();
-    fixed_time.tick(delta_time);
+    world.resource_mut::<Time>().prepare_fixed();
 
     // Run the schedule until we run out of accumulated time
     let _ = world.try_schedule_scope(FixedUpdate, |world, schedule| {
-        while world.resource_mut::<FixedTime>().expend().is_ok() {
+        while world.resource_mut::<Time>().tick_fixed() {
             schedule.run(world);
         }
     });
+
+    world.resource_mut::<Time>().finish_fixed();
 }
 
 #[cfg(test)]
diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index f462296ad6aef..2b435703de044 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -34,6 +34,10 @@ pub struct Time {
     raw_elapsed_wrapped: Duration,
     raw_elapsed_seconds_wrapped: f32,
     raw_elapsed_seconds_wrapped_f64: f64,
+    maximum_delta: Option<Duration>,
+    accumulated: Duration,
+    fixed_period: Duration,
+    stored_delta: Option<Duration>,
 }
 
 impl Default for Time {
@@ -63,6 +67,10 @@ impl Default for Time {
             raw_elapsed_wrapped: Duration::ZERO,
             raw_elapsed_seconds_wrapped: 0.0,
             raw_elapsed_seconds_wrapped_f64: 0.0,
+            maximum_delta: Some(Duration::from_millis(333)),
+            accumulated: Duration::ZERO,
+            fixed_period: Duration::from_secs_f32(1. / 60.), // XXX
+            stored_delta: None,
         }
     }
 }
@@ -138,6 +146,7 @@ impl Time {
     /// }
     /// ```
     pub fn update_with_instant(&mut self, instant: Instant) {
+        assert!(self.stored_delta.is_none());
         let raw_delta = instant - self.last_update.unwrap_or(self.startup);
         let delta = if self.paused {
             Duration::ZERO
@@ -147,6 +156,11 @@ impl Time {
             // avoid rounding when at normal speed
             raw_delta
         };
+        let delta = if let Some(maximum_delta) = self.maximum_delta {
+            std::cmp::min(delta, maximum_delta)
+        } else {
+            delta
+        };
 
         if self.last_update.is_some() {
             self.delta = delta;
@@ -159,6 +173,7 @@ impl Time {
             self.first_update = Some(instant);
         }
 
+        self.accumulated += delta;
         self.elapsed += delta;
         self.elapsed_seconds = self.elapsed.as_secs_f32();
         self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
@@ -176,6 +191,50 @@ impl Time {
         self.last_update = Some(instant);
     }
 
+    fn prepare_fixed(&mut self) {
+        assert!(self.stored_delta.is_none());
+        self.stored_delta = Some(self.delta);
+        self.delta = self.fixed_period;
+        self.delta_seconds = self.delta.as_secs_f32();
+        self.delta_seconds_f64 = self.delta.as_secs_f64();
+        self.elapsed -= self.accumulated;
+        self.elapsed_seconds = self.elapsed.as_secs_f32();
+        self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
+        self.elapsed_wrapped = duration_div_rem(self.elapsed, self.wrap_period).1;
+        self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
+        self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
+    }
+
+    fn expend_fixed(&mut self) -> bool {
+        assert!(self.stored_delta.is_some());
+        if let Some(new_value) = self.accumulated.checked_sub(self.fixed_period) {
+            self.accumulated = new_value;
+            self.elapsed += self.fixed_period;
+            self.elapsed_seconds = self.elapsed.as_secs_f32();
+            self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
+            self.elapsed_wrapped = duration_div_rem(self.elapsed, self.wrap_period).1;
+            self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
+            self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
+            true
+        } else {
+            false
+        }
+    }
+
+    fn finish_fixed(&mut self) {
+        assert!(self.stored_delta.is_some());
+        self.delta = self.stored_delta.unwrap();
+        self.delta_seconds = self.delta.as_secs_f32();
+        self.delta_seconds_f64 = self.delta.as_secs_f64();
+        self.elapsed += self.accumulated;
+        self.elapsed_seconds = self.elapsed.as_secs_f32();
+        self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
+        self.elapsed_wrapped = duration_div_rem(self.elapsed, self.wrap_period).1;
+        self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
+        self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
+        self.stored_delta = None;
+    }
+
     /// Returns the [`Instant`] the clock was created.
     ///
     /// This usually represents when the app was started.

From bd397d20248b3e6927085384a7ce6a91241fd15f Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Thu, 22 Jun 2023 13:55:32 +0000
Subject: [PATCH 02/16] Cleanups and comments

---
 crates/bevy_time/src/fixed_timestep.rs |  2 +-
 crates/bevy_time/src/time.rs           | 12 +++++++++---
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_time/src/fixed_timestep.rs b/crates/bevy_time/src/fixed_timestep.rs
index 9a31e1053dc33..66cc33df1d575 100644
--- a/crates/bevy_time/src/fixed_timestep.rs
+++ b/crates/bevy_time/src/fixed_timestep.rs
@@ -105,7 +105,7 @@ pub fn run_fixed_update_schedule(world: &mut World) {
 
     // Run the schedule until we run out of accumulated time
     let _ = world.try_schedule_scope(FixedUpdate, |world, schedule| {
-        while world.resource_mut::<Time>().tick_fixed() {
+        while world.resource_mut::<Time>().expend_fixed() {
             schedule.run(world);
         }
     });
diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index 2b435703de044..f077e6f96ade8 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -191,12 +191,14 @@ impl Time {
         self.last_update = Some(instant);
     }
 
-    fn prepare_fixed(&mut self) {
+    pub fn prepare_fixed(&mut self) {
         assert!(self.stored_delta.is_none());
+        // stash current delta since we don't have it anywhere else, also is used as a marker if we are in fixed time or not
         self.stored_delta = Some(self.delta);
         self.delta = self.fixed_period;
         self.delta_seconds = self.delta.as_secs_f32();
         self.delta_seconds_f64 = self.delta.as_secs_f64();
+        // rewind elapsed to time during last fixed update
         self.elapsed -= self.accumulated;
         self.elapsed_seconds = self.elapsed.as_secs_f32();
         self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
@@ -205,9 +207,10 @@ impl Time {
         self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
     }
 
-    fn expend_fixed(&mut self) -> bool {
+    pub fn expend_fixed(&mut self) -> bool {
         assert!(self.stored_delta.is_some());
         if let Some(new_value) = self.accumulated.checked_sub(self.fixed_period) {
+            // reduce accumulated and increase elapsed by period
             self.accumulated = new_value;
             self.elapsed += self.fixed_period;
             self.elapsed_seconds = self.elapsed.as_secs_f32();
@@ -217,15 +220,18 @@ impl Time {
             self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
             true
         } else {
+            // no more periods left in accumulated
             false
         }
     }
 
-    fn finish_fixed(&mut self) {
+    pub fn finish_fixed(&mut self) {
         assert!(self.stored_delta.is_some());
+        // restore delta from stashed delta
         self.delta = self.stored_delta.unwrap();
         self.delta_seconds = self.delta.as_secs_f32();
         self.delta_seconds_f64 = self.delta.as_secs_f64();
+        // add remainder of accumulated back to elapsed for Update stage
         self.elapsed += self.accumulated;
         self.elapsed_seconds = self.elapsed.as_secs_f32();
         self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();

From 02cbc0efc763a060e8cf851f2e63c6e1d4aa3d54 Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Fri, 23 Jun 2023 19:31:26 +0000
Subject: [PATCH 03/16] Second try of time unification

---
 crates/bevy_time/src/clock.rs          |  41 +++++
 crates/bevy_time/src/fixed_timestep.rs |   4 -
 crates/bevy_time/src/lib.rs            |   1 +
 crates/bevy_time/src/time.rs           | 206 ++++++++-----------------
 4 files changed, 110 insertions(+), 142 deletions(-)
 create mode 100644 crates/bevy_time/src/clock.rs

diff --git a/crates/bevy_time/src/clock.rs b/crates/bevy_time/src/clock.rs
new file mode 100644
index 0000000000000..d20ed9fbb5329
--- /dev/null
+++ b/crates/bevy_time/src/clock.rs
@@ -0,0 +1,41 @@
+use bevy_reflect::{FromReflect, Reflect};
+use bevy_utils::Duration;
+
+#[derive(Default, Debug, Copy, Clone, Reflect, FromReflect)]
+pub struct Clock {
+    pub wrap_seconds: u64,
+    pub delta: Duration,
+    pub delta_seconds: f32,
+    pub delta_seconds_f64: f64,
+    pub elapsed: Duration,
+    pub elapsed_seconds: f32,
+    pub elapsed_seconds_f64: f64,
+    pub elapsed_wrapped: Duration,
+    pub elapsed_seconds_wrapped: f32,
+    pub elapsed_seconds_wrapped_f64: f64,
+}
+
+impl Clock {
+    pub fn new(wrap_seconds: u64) -> Clock {
+        Clock {
+            wrap_seconds,
+            ..Default::default()
+        }
+    }
+
+    pub fn advance_by(&mut self, delta: Duration) {
+        self.delta = delta;
+        self.delta_seconds = self.delta.as_secs_f32();
+        self.delta_seconds_f64 = self.delta.as_secs_f64();
+        self.elapsed += delta;
+        self.elapsed_seconds = self.elapsed.as_secs_f32();
+        self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
+        self.elapsed_wrapped = Duration::new(self.elapsed.as_secs() % self.wrap_seconds, self.elapsed.subsec_nanos());
+        self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
+        self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
+    }
+
+    pub fn advance_to(&mut self, elapsed: Duration) {
+        self.advance_by(elapsed - self.elapsed)
+    }
+}
diff --git a/crates/bevy_time/src/fixed_timestep.rs b/crates/bevy_time/src/fixed_timestep.rs
index 66cc33df1d575..06ad91e511ee3 100644
--- a/crates/bevy_time/src/fixed_timestep.rs
+++ b/crates/bevy_time/src/fixed_timestep.rs
@@ -101,16 +101,12 @@ pub enum FixedUpdateError {
 
 /// Ticks the [`FixedTime`] resource then runs the [`FixedUpdate`].
 pub fn run_fixed_update_schedule(world: &mut World) {
-    world.resource_mut::<Time>().prepare_fixed();
-
     // Run the schedule until we run out of accumulated time
     let _ = world.try_schedule_scope(FixedUpdate, |world, schedule| {
         while world.resource_mut::<Time>().expend_fixed() {
             schedule.run(world);
         }
     });
-
-    world.resource_mut::<Time>().finish_fixed();
 }
 
 #[cfg(test)]
diff --git a/crates/bevy_time/src/lib.rs b/crates/bevy_time/src/lib.rs
index 704d54d860452..ac4ab511f73e7 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -7,6 +7,7 @@ mod stopwatch;
 #[allow(clippy::module_inception)]
 mod time;
 mod timer;
+mod clock;
 
 use fixed_timestep::FixedTime;
 pub use stopwatch::*;
diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index f077e6f96ade8..8522357bcfcc5 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -2,6 +2,8 @@ use bevy_ecs::{reflect::ReflectResource, system::Resource};
 use bevy_reflect::{FromReflect, Reflect};
 use bevy_utils::{Duration, Instant};
 
+use crate::clock::Clock;
+
 /// A clock that tracks how much it has advanced (and how much real time has elapsed) since
 /// its previous update and since its creation.
 #[derive(Resource, Reflect, FromReflect, Debug, Clone)]
@@ -14,30 +16,17 @@ pub struct Time {
     paused: bool,
     // scaling
     relative_speed: f64, // using `f64` instead of `f32` to minimize drift from rounding errors
-    delta: Duration,
-    delta_seconds: f32,
-    delta_seconds_f64: f64,
-    elapsed: Duration,
-    elapsed_seconds: f32,
-    elapsed_seconds_f64: f64,
-    raw_delta: Duration,
-    raw_delta_seconds: f32,
-    raw_delta_seconds_f64: f64,
-    raw_elapsed: Duration,
-    raw_elapsed_seconds: f32,
-    raw_elapsed_seconds_f64: f64,
     // wrapping
-    wrap_period: Duration,
-    elapsed_wrapped: Duration,
-    elapsed_seconds_wrapped: f32,
-    elapsed_seconds_wrapped_f64: f64,
-    raw_elapsed_wrapped: Duration,
-    raw_elapsed_seconds_wrapped: f32,
-    raw_elapsed_seconds_wrapped_f64: f64,
+    wrap_seconds: u64,
+
     maximum_delta: Option<Duration>,
-    accumulated: Duration,
+    fixed_accumulated: Duration,
     fixed_period: Duration,
-    stored_delta: Option<Duration>,
+
+    raw_clock: Clock,
+    virtual_clock: Clock,
+    fixed_clock: Clock,
+    current_clock: Clock,
 }
 
 impl Default for Time {
@@ -48,29 +37,14 @@ impl Default for Time {
             last_update: None,
             paused: false,
             relative_speed: 1.0,
-            delta: Duration::ZERO,
-            delta_seconds: 0.0,
-            delta_seconds_f64: 0.0,
-            elapsed: Duration::ZERO,
-            elapsed_seconds: 0.0,
-            elapsed_seconds_f64: 0.0,
-            raw_delta: Duration::ZERO,
-            raw_delta_seconds: 0.0,
-            raw_delta_seconds_f64: 0.0,
-            raw_elapsed: Duration::ZERO,
-            raw_elapsed_seconds: 0.0,
-            raw_elapsed_seconds_f64: 0.0,
-            wrap_period: Duration::from_secs(3600), // 1 hour
-            elapsed_wrapped: Duration::ZERO,
-            elapsed_seconds_wrapped: 0.0,
-            elapsed_seconds_wrapped_f64: 0.0,
-            raw_elapsed_wrapped: Duration::ZERO,
-            raw_elapsed_seconds_wrapped: 0.0,
-            raw_elapsed_seconds_wrapped_f64: 0.0,
+            wrap_seconds: 3600, // 1 hour
             maximum_delta: Some(Duration::from_millis(333)),
-            accumulated: Duration::ZERO,
+            fixed_accumulated: Duration::ZERO,
             fixed_period: Duration::from_secs_f32(1. / 60.), // XXX
-            stored_delta: None,
+            raw_clock: Clock::new(3600),
+            virtual_clock: Clock::new(3600),
+            fixed_clock: Clock::new(3600),
+            current_clock: Clock::new(3600),
         }
     }
 }
@@ -146,9 +120,9 @@ impl Time {
     /// }
     /// ```
     pub fn update_with_instant(&mut self, instant: Instant) {
-        assert!(self.stored_delta.is_none());
         let raw_delta = instant - self.last_update.unwrap_or(self.startup);
-        let delta = if self.paused {
+        self.raw_clock.advance_by(raw_delta);
+        let scaled_delta = if self.paused {
             Duration::ZERO
         } else if self.relative_speed != 1.0 {
             raw_delta.mul_f64(self.relative_speed)
@@ -157,90 +131,37 @@ impl Time {
             raw_delta
         };
         let delta = if let Some(maximum_delta) = self.maximum_delta {
-            std::cmp::min(delta, maximum_delta)
+            std::cmp::min(scaled_delta, maximum_delta)
         } else {
-            delta
+            scaled_delta
         };
+        self.virtual_clock.advance_by(delta);
+        self.fixed_accumulated += delta;
 
-        if self.last_update.is_some() {
-            self.delta = delta;
-            self.delta_seconds = self.delta.as_secs_f32();
-            self.delta_seconds_f64 = self.delta.as_secs_f64();
-            self.raw_delta = raw_delta;
-            self.raw_delta_seconds = self.raw_delta.as_secs_f32();
-            self.raw_delta_seconds_f64 = self.raw_delta.as_secs_f64();
-        } else {
+        if self.last_update.is_none() {
             self.first_update = Some(instant);
+            // on first actual update, zero out delta so we do not get a big jump due to startup systems
+            self.raw_clock.advance_by(Duration::ZERO);
+            self.virtual_clock.advance_by(Duration::ZERO);
         }
-
-        self.accumulated += delta;
-        self.elapsed += delta;
-        self.elapsed_seconds = self.elapsed.as_secs_f32();
-        self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
-        self.raw_elapsed += raw_delta;
-        self.raw_elapsed_seconds = self.raw_elapsed.as_secs_f32();
-        self.raw_elapsed_seconds_f64 = self.raw_elapsed.as_secs_f64();
-
-        self.elapsed_wrapped = duration_div_rem(self.elapsed, self.wrap_period).1;
-        self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
-        self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
-        self.raw_elapsed_wrapped = duration_div_rem(self.raw_elapsed, self.wrap_period).1;
-        self.raw_elapsed_seconds_wrapped = self.raw_elapsed_wrapped.as_secs_f32();
-        self.raw_elapsed_seconds_wrapped_f64 = self.raw_elapsed_wrapped.as_secs_f64();
-
         self.last_update = Some(instant);
-    }
-
-    pub fn prepare_fixed(&mut self) {
-        assert!(self.stored_delta.is_none());
-        // stash current delta since we don't have it anywhere else, also is used as a marker if we are in fixed time or not
-        self.stored_delta = Some(self.delta);
-        self.delta = self.fixed_period;
-        self.delta_seconds = self.delta.as_secs_f32();
-        self.delta_seconds_f64 = self.delta.as_secs_f64();
-        // rewind elapsed to time during last fixed update
-        self.elapsed -= self.accumulated;
-        self.elapsed_seconds = self.elapsed.as_secs_f32();
-        self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
-        self.elapsed_wrapped = duration_div_rem(self.elapsed, self.wrap_period).1;
-        self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
-        self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
+        self.current_clock = self.virtual_clock;
     }
 
     pub fn expend_fixed(&mut self) -> bool {
-        assert!(self.stored_delta.is_some());
-        if let Some(new_value) = self.accumulated.checked_sub(self.fixed_period) {
+        if let Some(new_value) = self.fixed_accumulated.checked_sub(self.fixed_period) {
             // reduce accumulated and increase elapsed by period
-            self.accumulated = new_value;
-            self.elapsed += self.fixed_period;
-            self.elapsed_seconds = self.elapsed.as_secs_f32();
-            self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
-            self.elapsed_wrapped = duration_div_rem(self.elapsed, self.wrap_period).1;
-            self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
-            self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
+            self.fixed_accumulated = new_value;
+            self.fixed_clock.advance_by(self.fixed_period);
+            self.current_clock = self.fixed_clock;
             true
         } else {
             // no more periods left in accumulated
+            self.current_clock = self.virtual_clock;
             false
         }
     }
 
-    pub fn finish_fixed(&mut self) {
-        assert!(self.stored_delta.is_some());
-        // restore delta from stashed delta
-        self.delta = self.stored_delta.unwrap();
-        self.delta_seconds = self.delta.as_secs_f32();
-        self.delta_seconds_f64 = self.delta.as_secs_f64();
-        // add remainder of accumulated back to elapsed for Update stage
-        self.elapsed += self.accumulated;
-        self.elapsed_seconds = self.elapsed.as_secs_f32();
-        self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
-        self.elapsed_wrapped = duration_div_rem(self.elapsed, self.wrap_period).1;
-        self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
-        self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
-        self.stored_delta = None;
-    }
-
     /// Returns the [`Instant`] the clock was created.
     ///
     /// This usually represents when the app was started.
@@ -268,25 +189,25 @@ impl Time {
     /// Returns how much time has advanced since the last [`update`](#method.update), as a [`Duration`].
     #[inline]
     pub fn delta(&self) -> Duration {
-        self.delta
+        self.current_clock.delta
     }
 
     /// Returns how much time has advanced since the last [`update`](#method.update), as [`f32`] seconds.
     #[inline]
     pub fn delta_seconds(&self) -> f32 {
-        self.delta_seconds
+        self.current_clock.delta_seconds
     }
 
     /// Returns how much time has advanced since the last [`update`](#method.update), as [`f64`] seconds.
     #[inline]
     pub fn delta_seconds_f64(&self) -> f64 {
-        self.delta_seconds_f64
+        self.current_clock.delta_seconds_f64
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup), as [`Duration`].
     #[inline]
     pub fn elapsed(&self) -> Duration {
-        self.elapsed
+        self.current_clock.elapsed
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup), as [`f32`] seconds.
@@ -296,20 +217,20 @@ impl Time {
     /// use [`elapsed_seconds_wrapped`](#method.elapsed_seconds_wrapped).
     #[inline]
     pub fn elapsed_seconds(&self) -> f32 {
-        self.elapsed_seconds
+        self.current_clock.elapsed_seconds
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup), as [`f64`] seconds.
     #[inline]
     pub fn elapsed_seconds_f64(&self) -> f64 {
-        self.elapsed_seconds_f64
+        self.current_clock.elapsed_seconds_f64
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup) modulo
     /// the [`wrap_period`](#method.wrap_period), as [`Duration`].
     #[inline]
     pub fn elapsed_wrapped(&self) -> Duration {
-        self.elapsed_wrapped
+        self.current_clock.elapsed_wrapped
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup) modulo
@@ -319,38 +240,38 @@ impl Time {
     /// suffer from the gradual precision loss of [`elapsed_seconds`](#method.elapsed_seconds).
     #[inline]
     pub fn elapsed_seconds_wrapped(&self) -> f32 {
-        self.elapsed_seconds_wrapped
+        self.current_clock.elapsed_seconds_wrapped
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup) modulo
     /// the [`wrap_period`](#method.wrap_period), as [`f64`] seconds.
     #[inline]
     pub fn elapsed_seconds_wrapped_f64(&self) -> f64 {
-        self.elapsed_seconds_wrapped_f64
+        self.current_clock.elapsed_seconds_wrapped_f64
     }
 
     /// Returns how much real time has elapsed since the last [`update`](#method.update), as a [`Duration`].
     #[inline]
     pub fn raw_delta(&self) -> Duration {
-        self.raw_delta
+        self.raw_clock.delta
     }
 
     /// Returns how much real time has elapsed since the last [`update`](#method.update), as [`f32`] seconds.
     #[inline]
     pub fn raw_delta_seconds(&self) -> f32 {
-        self.raw_delta_seconds
+        self.raw_clock.delta_seconds
     }
 
     /// Returns how much real time has elapsed since the last [`update`](#method.update), as [`f64`] seconds.
     #[inline]
     pub fn raw_delta_seconds_f64(&self) -> f64 {
-        self.raw_delta_seconds_f64
+        self.raw_clock.delta_seconds_f64
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup), as [`Duration`].
     #[inline]
     pub fn raw_elapsed(&self) -> Duration {
-        self.raw_elapsed
+        self.raw_clock.elapsed
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup), as [`f32`] seconds.
@@ -360,20 +281,20 @@ impl Time {
     /// use [`raw_elapsed_seconds_wrapped`](#method.raw_elapsed_seconds_wrapped).
     #[inline]
     pub fn raw_elapsed_seconds(&self) -> f32 {
-        self.raw_elapsed_seconds
+        self.raw_clock.elapsed_seconds
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup), as [`f64`] seconds.
     #[inline]
     pub fn raw_elapsed_seconds_f64(&self) -> f64 {
-        self.raw_elapsed_seconds_f64
+        self.raw_clock.elapsed_seconds_f64
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup) modulo
     /// the [`wrap_period`](#method.wrap_period), as [`Duration`].
     #[inline]
     pub fn raw_elapsed_wrapped(&self) -> Duration {
-        self.raw_elapsed_wrapped
+        self.raw_clock.elapsed_wrapped
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup) modulo
@@ -383,14 +304,14 @@ impl Time {
     /// suffer from the gradual precision loss of [`raw_elapsed_seconds`](#method.raw_elapsed_seconds).
     #[inline]
     pub fn raw_elapsed_seconds_wrapped(&self) -> f32 {
-        self.raw_elapsed_seconds_wrapped
+        self.raw_clock.elapsed_seconds_wrapped
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup) modulo
     /// the [`wrap_period`](#method.wrap_period), as [`f64`] seconds.
     #[inline]
     pub fn raw_elapsed_seconds_wrapped_f64(&self) -> f64 {
-        self.raw_elapsed_seconds_wrapped_f64
+        self.raw_clock.elapsed_seconds_wrapped_f64
     }
 
     /// Returns the modulus used to calculate [`elapsed_wrapped`](#method.elapsed_wrapped) and
@@ -399,7 +320,7 @@ impl Time {
     /// **Note:** The default modulus is one hour.
     #[inline]
     pub fn wrap_period(&self) -> Duration {
-        self.wrap_period
+        Duration::from_secs(self.wrap_seconds)
     }
 
     /// Sets the modulus used to calculate [`elapsed_wrapped`](#method.elapsed_wrapped) and
@@ -413,7 +334,11 @@ impl Time {
     #[inline]
     pub fn set_wrap_period(&mut self, wrap_period: Duration) {
         assert!(!wrap_period.is_zero(), "division by zero");
-        self.wrap_period = wrap_period;
+        assert_eq!(wrap_period.subsec_nanos(), 0, "wrap period must be integral seconds");
+        self.wrap_seconds = wrap_period.as_secs();
+        self.raw_clock.wrap_seconds = self.wrap_seconds;
+        self.virtual_clock.wrap_seconds = self.wrap_seconds;
+        self.fixed_clock.wrap_seconds = self.wrap_seconds;
     }
 
     /// Returns the speed the clock advances relative to your system clock, as [`f32`].
@@ -487,13 +412,18 @@ impl Time {
     pub fn is_paused(&self) -> bool {
         self.paused
     }
-}
 
-fn duration_div_rem(dividend: Duration, divisor: Duration) -> (u32, Duration) {
-    // `Duration` does not have a built-in modulo operation
-    let quotient = (dividend.as_nanos() / divisor.as_nanos()) as u32;
-    let remainder = dividend - (quotient * divisor);
-    (quotient, remainder)
+    pub fn raw_clock(&self) -> &Clock {
+        &self.raw_clock
+    }
+
+    pub fn virtual_clock(&self) -> &Clock {
+        &self.virtual_clock
+    }
+
+    pub fn fixed_clock(&self) -> &Clock {
+        &self.fixed_clock
+    }
 }
 
 #[cfg(test)]
@@ -619,7 +549,7 @@ mod tests {
 
         let mut time = Time {
             startup: start_instant,
-            wrap_period: Duration::from_secs(3),
+            wrap_seconds: 3,
             ..Default::default()
         };
 

From 4fa2ef77b55b8d391509cfbe065bfaecca0d4944 Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Fri, 23 Jun 2023 19:34:46 +0000
Subject: [PATCH 04/16] Forgot current clock

---
 crates/bevy_time/src/time.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index 8522357bcfcc5..93b70a974813c 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -424,6 +424,10 @@ impl Time {
     pub fn fixed_clock(&self) -> &Clock {
         &self.fixed_clock
     }
+
+    pub fn current_clock(&self) -> &Clock {
+        &self.current_clock
+    }
 }
 
 #[cfg(test)]

From 1298507170e2bc837d316da13472e722c37b6250 Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 13:51:16 +0000
Subject: [PATCH 05/16] Improve clock to not have public data members

---
 crates/bevy_time/src/clock.rs | 77 +++++++++++++++++++++++++++++------
 1 file changed, 65 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_time/src/clock.rs b/crates/bevy_time/src/clock.rs
index d20ed9fbb5329..832d6c3cd599a 100644
--- a/crates/bevy_time/src/clock.rs
+++ b/crates/bevy_time/src/clock.rs
@@ -1,25 +1,35 @@
 use bevy_reflect::{FromReflect, Reflect};
 use bevy_utils::Duration;
 
-#[derive(Default, Debug, Copy, Clone, Reflect, FromReflect)]
+#[derive(Debug, Copy, Clone, Reflect, FromReflect)]
 pub struct Clock {
-    pub wrap_seconds: u64,
-    pub delta: Duration,
-    pub delta_seconds: f32,
-    pub delta_seconds_f64: f64,
-    pub elapsed: Duration,
-    pub elapsed_seconds: f32,
-    pub elapsed_seconds_f64: f64,
-    pub elapsed_wrapped: Duration,
-    pub elapsed_seconds_wrapped: f32,
-    pub elapsed_seconds_wrapped_f64: f64,
+    wrap_seconds: u64,
+    delta: Duration,
+    delta_seconds: f32,
+    delta_seconds_f64: f64,
+    elapsed: Duration,
+    elapsed_seconds: f32,
+    elapsed_seconds_f64: f64,
+    elapsed_wrapped: Duration,
+    elapsed_seconds_wrapped: f32,
+    elapsed_seconds_wrapped_f64: f64,
 }
 
 impl Clock {
+    const DEFAULT_WRAP_SECONDS: u64 = 3600; // 1 hour
+
     pub fn new(wrap_seconds: u64) -> Clock {
         Clock {
             wrap_seconds,
-            ..Default::default()
+            delta: Duration::ZERO,
+            delta_seconds: 0.0,
+            delta_seconds_f64: 0.0,
+            elapsed: Duration::ZERO,
+            elapsed_seconds: 0.0,
+            elapsed_seconds_f64: 0.0,
+            elapsed_wrapped: Duration::ZERO,
+            elapsed_seconds_wrapped: 0.0,
+            elapsed_seconds_wrapped_f64: 0.0,
         }
     }
 
@@ -38,4 +48,47 @@ impl Clock {
     pub fn advance_to(&mut self, elapsed: Duration) {
         self.advance_by(elapsed - self.elapsed)
     }
+
+    pub fn delta(&self) -> Duration {
+        self.delta
+    }
+
+    pub fn delta_seconds(&self) -> f32 {
+        self.delta_seconds
+    }
+
+    pub fn delta_seconds_f64(&self) -> f64 {
+        self.delta_seconds_f64
+    }
+
+    pub fn elapsed_wrapped(&self) -> Duration {
+        self.elapsed_wrapped
+    }
+
+    pub fn elapsed_seconds_wrapped(&self) -> f32 {
+        self.elapsed_seconds_wrapped
+    }
+
+    pub fn elapsed_seconds_wrapped_f64(&self) -> f64 {
+        self.elapsed_seconds_wrapped_f64
+    }
+
+    pub fn wrap_period(&self) -> Duration {
+        Duration::from_secs(self.wrap_seconds)
+    }
+
+    pub fn set_wrap_period(&mut self, wrap_period: Duration) {
+        assert!(!wrap_period.is_zero(), "division by zero");
+        assert_eq!(wrap_period.subsec_nanos(), 0, "wrap period must be integral seconds");
+        self.wrap_seconds = wrap_period.as_secs();
+        self.elapsed_wrapped = Duration::new(self.elapsed.as_secs() % self.wrap_seconds, self.elapsed.subsec_nanos());
+        self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
+        self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();        
+    }
+}
+
+impl Default for Clock {
+    fn default() -> Self {
+        Self::new(Self::DEFAULT_WRAP_SECONDS)
+    }
 }

From 0c6303ff69cbff7de6ec8f5c165ebddb6f83e941 Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 13:53:38 +0000
Subject: [PATCH 06/16] Whoops copypaste error

---
 crates/bevy_time/src/clock.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/crates/bevy_time/src/clock.rs b/crates/bevy_time/src/clock.rs
index 832d6c3cd599a..8e6b532ee0c99 100644
--- a/crates/bevy_time/src/clock.rs
+++ b/crates/bevy_time/src/clock.rs
@@ -61,6 +61,18 @@ impl Clock {
         self.delta_seconds_f64
     }
 
+    pub fn elapsed(&self) -> Duration {
+        self.elapsed
+    }
+
+    pub fn elapsed_seconds(&self) -> f32 {
+        self.elapsed_seconds
+    }
+
+    pub fn elapsed_seconds_f64(&self) -> f64 {
+        self.elapsed_seconds_f64
+    }
+
     pub fn elapsed_wrapped(&self) -> Duration {
         self.elapsed_wrapped
     }

From 9312fbc0e6e8d0866afa0f140b3e13b89dccd8fd Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 13:57:55 +0000
Subject: [PATCH 07/16] Cleanups to time to make it compile and work again

---
 crates/bevy_time/src/time.rs | 69 +++++++++++++++---------------------
 1 file changed, 29 insertions(+), 40 deletions(-)

diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index 93b70a974813c..232b892279d3e 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -12,13 +12,8 @@ pub struct Time {
     startup: Instant,
     first_update: Option<Instant>,
     last_update: Option<Instant>,
-    // pausing
     paused: bool,
-    // scaling
     relative_speed: f64, // using `f64` instead of `f32` to minimize drift from rounding errors
-    // wrapping
-    wrap_seconds: u64,
-
     maximum_delta: Option<Duration>,
     fixed_accumulated: Duration,
     fixed_period: Duration,
@@ -37,14 +32,13 @@ impl Default for Time {
             last_update: None,
             paused: false,
             relative_speed: 1.0,
-            wrap_seconds: 3600, // 1 hour
             maximum_delta: Some(Duration::from_millis(333)),
             fixed_accumulated: Duration::ZERO,
             fixed_period: Duration::from_secs_f32(1. / 60.), // XXX
-            raw_clock: Clock::new(3600),
-            virtual_clock: Clock::new(3600),
-            fixed_clock: Clock::new(3600),
-            current_clock: Clock::new(3600),
+            raw_clock: Clock::default(),
+            virtual_clock: Clock::default(),
+            fixed_clock: Clock::default(),
+            current_clock: Clock::default(),
         }
     }
 }
@@ -189,25 +183,25 @@ impl Time {
     /// Returns how much time has advanced since the last [`update`](#method.update), as a [`Duration`].
     #[inline]
     pub fn delta(&self) -> Duration {
-        self.current_clock.delta
+        self.current_clock.delta()
     }
 
     /// Returns how much time has advanced since the last [`update`](#method.update), as [`f32`] seconds.
     #[inline]
     pub fn delta_seconds(&self) -> f32 {
-        self.current_clock.delta_seconds
+        self.current_clock.delta_seconds()
     }
 
     /// Returns how much time has advanced since the last [`update`](#method.update), as [`f64`] seconds.
     #[inline]
     pub fn delta_seconds_f64(&self) -> f64 {
-        self.current_clock.delta_seconds_f64
+        self.current_clock.delta_seconds_f64()
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup), as [`Duration`].
     #[inline]
     pub fn elapsed(&self) -> Duration {
-        self.current_clock.elapsed
+        self.current_clock.elapsed()
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup), as [`f32`] seconds.
@@ -217,20 +211,20 @@ impl Time {
     /// use [`elapsed_seconds_wrapped`](#method.elapsed_seconds_wrapped).
     #[inline]
     pub fn elapsed_seconds(&self) -> f32 {
-        self.current_clock.elapsed_seconds
+        self.current_clock.elapsed_seconds()
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup), as [`f64`] seconds.
     #[inline]
     pub fn elapsed_seconds_f64(&self) -> f64 {
-        self.current_clock.elapsed_seconds_f64
+        self.current_clock.elapsed_seconds_f64()
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup) modulo
     /// the [`wrap_period`](#method.wrap_period), as [`Duration`].
     #[inline]
     pub fn elapsed_wrapped(&self) -> Duration {
-        self.current_clock.elapsed_wrapped
+        self.current_clock.elapsed_wrapped()
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup) modulo
@@ -240,38 +234,38 @@ impl Time {
     /// suffer from the gradual precision loss of [`elapsed_seconds`](#method.elapsed_seconds).
     #[inline]
     pub fn elapsed_seconds_wrapped(&self) -> f32 {
-        self.current_clock.elapsed_seconds_wrapped
+        self.current_clock.elapsed_seconds_wrapped()
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup) modulo
     /// the [`wrap_period`](#method.wrap_period), as [`f64`] seconds.
     #[inline]
     pub fn elapsed_seconds_wrapped_f64(&self) -> f64 {
-        self.current_clock.elapsed_seconds_wrapped_f64
+        self.current_clock.elapsed_seconds_wrapped_f64()
     }
 
     /// Returns how much real time has elapsed since the last [`update`](#method.update), as a [`Duration`].
     #[inline]
     pub fn raw_delta(&self) -> Duration {
-        self.raw_clock.delta
+        self.raw_clock.delta()
     }
 
     /// Returns how much real time has elapsed since the last [`update`](#method.update), as [`f32`] seconds.
     #[inline]
     pub fn raw_delta_seconds(&self) -> f32 {
-        self.raw_clock.delta_seconds
+        self.raw_clock.delta_seconds()
     }
 
     /// Returns how much real time has elapsed since the last [`update`](#method.update), as [`f64`] seconds.
     #[inline]
     pub fn raw_delta_seconds_f64(&self) -> f64 {
-        self.raw_clock.delta_seconds_f64
+        self.raw_clock.delta_seconds_f64()
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup), as [`Duration`].
     #[inline]
     pub fn raw_elapsed(&self) -> Duration {
-        self.raw_clock.elapsed
+        self.raw_clock.elapsed()
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup), as [`f32`] seconds.
@@ -281,20 +275,20 @@ impl Time {
     /// use [`raw_elapsed_seconds_wrapped`](#method.raw_elapsed_seconds_wrapped).
     #[inline]
     pub fn raw_elapsed_seconds(&self) -> f32 {
-        self.raw_clock.elapsed_seconds
+        self.raw_clock.elapsed_seconds()
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup), as [`f64`] seconds.
     #[inline]
     pub fn raw_elapsed_seconds_f64(&self) -> f64 {
-        self.raw_clock.elapsed_seconds_f64
+        self.raw_clock.elapsed_seconds_f64()
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup) modulo
     /// the [`wrap_period`](#method.wrap_period), as [`Duration`].
     #[inline]
     pub fn raw_elapsed_wrapped(&self) -> Duration {
-        self.raw_clock.elapsed_wrapped
+        self.raw_clock.elapsed_wrapped()
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup) modulo
@@ -304,14 +298,14 @@ impl Time {
     /// suffer from the gradual precision loss of [`raw_elapsed_seconds`](#method.raw_elapsed_seconds).
     #[inline]
     pub fn raw_elapsed_seconds_wrapped(&self) -> f32 {
-        self.raw_clock.elapsed_seconds_wrapped
+        self.raw_clock.elapsed_seconds_wrapped()
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup) modulo
     /// the [`wrap_period`](#method.wrap_period), as [`f64`] seconds.
     #[inline]
     pub fn raw_elapsed_seconds_wrapped_f64(&self) -> f64 {
-        self.raw_clock.elapsed_seconds_wrapped_f64
+        self.raw_clock.elapsed_seconds_wrapped_f64()
     }
 
     /// Returns the modulus used to calculate [`elapsed_wrapped`](#method.elapsed_wrapped) and
@@ -320,7 +314,7 @@ impl Time {
     /// **Note:** The default modulus is one hour.
     #[inline]
     pub fn wrap_period(&self) -> Duration {
-        Duration::from_secs(self.wrap_seconds)
+        self.current_clock.wrap_period()
     }
 
     /// Sets the modulus used to calculate [`elapsed_wrapped`](#method.elapsed_wrapped) and
@@ -333,12 +327,10 @@ impl Time {
     /// Panics if `wrap_period` is a zero-length duration.
     #[inline]
     pub fn set_wrap_period(&mut self, wrap_period: Duration) {
-        assert!(!wrap_period.is_zero(), "division by zero");
-        assert_eq!(wrap_period.subsec_nanos(), 0, "wrap period must be integral seconds");
-        self.wrap_seconds = wrap_period.as_secs();
-        self.raw_clock.wrap_seconds = self.wrap_seconds;
-        self.virtual_clock.wrap_seconds = self.wrap_seconds;
-        self.fixed_clock.wrap_seconds = self.wrap_seconds;
+        self.raw_clock.set_wrap_period(wrap_period);
+        self.virtual_clock.set_wrap_period(wrap_period);
+        self.fixed_clock.set_wrap_period(wrap_period);
+        self.current_clock.set_wrap_period(wrap_period);
     }
 
     /// Returns the speed the clock advances relative to your system clock, as [`f32`].
@@ -551,11 +543,8 @@ mod tests {
     fn wrapping_test() {
         let start_instant = Instant::now();
 
-        let mut time = Time {
-            startup: start_instant,
-            wrap_seconds: 3,
-            ..Default::default()
-        };
+        let mut time = Time::new(start_instant);
+        time.set_wrap_period(Duration::from_secs(3));
 
         assert_eq!(time.elapsed_seconds_wrapped(), 0.0);
 

From 717c9ed442cb820ba8f760137738e6163caf7998 Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 14:03:26 +0000
Subject: [PATCH 08/16] Expose fixed period

---
 crates/bevy_time/src/time.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index 232b892279d3e..5682d8ea9faf4 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -333,6 +333,14 @@ impl Time {
         self.current_clock.set_wrap_period(wrap_period);
     }
 
+    pub fn fixed_period(&self) -> Duration {
+        self.fixed_period
+    }
+
+    pub fn set_fixed_period(&mut self, period: Duration) {
+        self.fixed_period = period;
+    }
+
     /// Returns the speed the clock advances relative to your system clock, as [`f32`].
     /// This is known as "time scaling" or "time dilation" in other engines.
     ///

From 205d534cb5cd64a039b4ebc6ff7ed892e025dd1e Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 14:03:52 +0000
Subject: [PATCH 09/16] Remove fixed timestep and everything related

---
 crates/bevy_time/src/common_conditions.rs |  8 +--
 crates/bevy_time/src/fixed_timestep.rs    | 76 +----------------------
 crates/bevy_time/src/lib.rs               |  4 +-
 3 files changed, 6 insertions(+), 82 deletions(-)

diff --git a/crates/bevy_time/src/common_conditions.rs b/crates/bevy_time/src/common_conditions.rs
index 974de24dfae2c..82e74e325a592 100644
--- a/crates/bevy_time/src/common_conditions.rs
+++ b/crates/bevy_time/src/common_conditions.rs
@@ -1,4 +1,4 @@
-use crate::{fixed_timestep::FixedTime, Time, Timer, TimerMode};
+use crate::{Time, Timer, TimerMode};
 use bevy_ecs::system::Res;
 use bevy_utils::Duration;
 
@@ -66,10 +66,10 @@ pub fn on_timer(duration: Duration) -> impl FnMut(Res<Time>) -> bool + Clone {
 /// Note that this run condition may not behave as expected if `duration` is smaller
 /// than the fixed timestep period, since the timer may complete multiple times in
 /// one fixed update.
-pub fn on_fixed_timer(duration: Duration) -> impl FnMut(Res<FixedTime>) -> bool + Clone {
+pub fn on_fixed_timer(duration: Duration) -> impl FnMut(Res<Time>) -> bool + Clone {
     let mut timer = Timer::new(duration, TimerMode::Repeating);
-    move |time: Res<FixedTime>| {
-        timer.tick(time.period);
+    move |time: Res<Time>| {
+        timer.tick(time.fixed_period());
         timer.just_finished()
     }
 }
diff --git a/crates/bevy_time/src/fixed_timestep.rs b/crates/bevy_time/src/fixed_timestep.rs
index 06ad91e511ee3..d2632c3f0f937 100644
--- a/crates/bevy_time/src/fixed_timestep.rs
+++ b/crates/bevy_time/src/fixed_timestep.rs
@@ -23,81 +23,7 @@
 
 use crate::Time;
 use bevy_app::FixedUpdate;
-use bevy_ecs::{system::Resource, world::World};
-use bevy_utils::Duration;
-use thiserror::Error;
-
-/// The amount of time that must pass before the fixed timestep schedule is run again.
-#[derive(Resource, Debug)]
-pub struct FixedTime {
-    accumulated: Duration,
-    /// Defaults to 1/60th of a second.
-    /// To configure this value, simply mutate or overwrite this resource.
-    pub period: Duration,
-}
-
-impl FixedTime {
-    /// Creates a new [`FixedTime`] struct
-    pub fn new(period: Duration) -> Self {
-        FixedTime {
-            accumulated: Duration::ZERO,
-            period,
-        }
-    }
-
-    /// Creates a new [`FixedTime`] struct with a period specified in `f32` seconds
-    pub fn new_from_secs(period: f32) -> Self {
-        FixedTime {
-            accumulated: Duration::ZERO,
-            period: Duration::from_secs_f32(period),
-        }
-    }
-
-    /// Adds the `delta_time` to the accumulated time so far.
-    pub fn tick(&mut self, delta_time: Duration) {
-        self.accumulated += delta_time;
-    }
-
-    /// Returns the current amount of accumulated time
-    pub fn accumulated(&self) -> Duration {
-        self.accumulated
-    }
-
-    /// Expends one `period` of accumulated time.
-    ///
-    /// [`Err(FixedUpdateError`)] will be returned if there is
-    /// not enough accumulated time to span an entire period.
-    pub fn expend(&mut self) -> Result<(), FixedUpdateError> {
-        if let Some(new_value) = self.accumulated.checked_sub(self.period) {
-            self.accumulated = new_value;
-            Ok(())
-        } else {
-            Err(FixedUpdateError::NotEnoughTime {
-                accumulated: self.accumulated,
-                period: self.period,
-            })
-        }
-    }
-}
-
-impl Default for FixedTime {
-    fn default() -> Self {
-        FixedTime {
-            accumulated: Duration::ZERO,
-            period: Duration::from_secs_f32(1. / 60.),
-        }
-    }
-}
-
-/// An error returned when working with [`FixedTime`].
-#[derive(Debug, Error)]
-pub enum FixedUpdateError {
-    #[error("At least one period worth of time must be accumulated.")]
-    NotEnoughTime {
-        accumulated: Duration,
-        period: Duration,
-    },
-}
+use bevy_ecs::world::World;
 
 /// Ticks the [`FixedTime`] resource then runs the [`FixedUpdate`].
 pub fn run_fixed_update_schedule(world: &mut World) {
diff --git a/crates/bevy_time/src/lib.rs b/crates/bevy_time/src/lib.rs
index ac4ab511f73e7..f94e399633713 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -9,7 +9,6 @@ mod time;
 mod timer;
 mod clock;
 
-use fixed_timestep::FixedTime;
 pub use stopwatch::*;
 pub use time::*;
 pub use timer::*;
@@ -21,7 +20,7 @@ use crossbeam_channel::{Receiver, Sender};
 pub mod prelude {
     //! The Bevy Time Prelude.
     #[doc(hidden)]
-    pub use crate::{fixed_timestep::FixedTime, Time, Timer, TimerMode};
+    pub use crate::{Time, Timer, TimerMode};
 }
 
 use bevy_app::{prelude::*, RunFixedUpdateLoop};
@@ -45,7 +44,6 @@ impl Plugin for TimePlugin {
             .register_type::<Timer>()
             .register_type::<Time>()
             .register_type::<Stopwatch>()
-            .init_resource::<FixedTime>()
             .add_systems(First, time_system.in_set(TimeSystem))
             .add_systems(RunFixedUpdateLoop, run_fixed_update_schedule);
 

From 5b15585919744a25c91c6253c8d7f64dc396fd0e Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 14:23:22 +0000
Subject: [PATCH 10/16] Expose max delta as well

---
 crates/bevy_time/src/time.rs | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index 5682d8ea9faf4..77553a6fc4907 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -17,7 +17,6 @@ pub struct Time {
     maximum_delta: Option<Duration>,
     fixed_accumulated: Duration,
     fixed_period: Duration,
-
     raw_clock: Clock,
     virtual_clock: Clock,
     fixed_clock: Clock,
@@ -32,7 +31,7 @@ impl Default for Time {
             last_update: None,
             paused: false,
             relative_speed: 1.0,
-            maximum_delta: Some(Duration::from_millis(333)),
+            maximum_delta: None, // XXX
             fixed_accumulated: Duration::ZERO,
             fixed_period: Duration::from_secs_f32(1. / 60.), // XXX
             raw_clock: Clock::default(),
@@ -341,6 +340,14 @@ impl Time {
         self.fixed_period = period;
     }
 
+    pub fn maximum_delta(&self) -> Option<Duration> {
+        self.maximum_delta
+    }
+
+    pub fn set_maximum_delta(&mut self, maximum_delta: Option<Duration>) {
+        self.maximum_delta = maximum_delta;
+    }
+
     /// Returns the speed the clock advances relative to your system clock, as [`f32`].
     /// This is known as "time scaling" or "time dilation" in other engines.
     ///
@@ -430,11 +437,22 @@ impl Time {
     }
 }
 
+/// Ticks the [`FixedTime`] resource then runs the [`FixedUpdate`].
+pub fn run_fixed_update_schedule(world: &mut World) {
+    // Run the schedule until we run out of accumulated time
+    let _ = world.try_schedule_scope(FixedUpdate, |world, schedule| {
+        while world.resource_mut::<Time>().expend_fixed() {
+            schedule.run(world);
+        }
+    });
+}
+
 #[cfg(test)]
 #[allow(clippy::float_cmp)]
 mod tests {
     use super::Time;
     use bevy_utils::{Duration, Instant};
+    
 
     fn assert_float_eq(a: f32, b: f32) {
         assert!((a - b).abs() <= f32::EPSILON, "{a} != {b}");

From 065b93e4bb96dd8f83618dabaa79e5c0467b2a3e Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 14:24:53 +0000
Subject: [PATCH 11/16] Remove fixed_timestep entirely and fix tests

---
 crates/bevy_time/src/fixed_timestep.rs | 79 --------------------------
 crates/bevy_time/src/lib.rs            |  3 +-
 crates/bevy_time/src/time.rs           | 53 ++++++++++++++++-
 3 files changed, 53 insertions(+), 82 deletions(-)
 delete mode 100644 crates/bevy_time/src/fixed_timestep.rs

diff --git a/crates/bevy_time/src/fixed_timestep.rs b/crates/bevy_time/src/fixed_timestep.rs
deleted file mode 100644
index d2632c3f0f937..0000000000000
--- a/crates/bevy_time/src/fixed_timestep.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-//! Tools to run systems at a regular interval.
-//! This can be extremely useful for steady, frame-rate independent gameplay logic and physics.
-//!
-//! To run a system on a fixed timestep, add it to the [`FixedUpdate`] [`Schedule`](bevy_ecs::schedule::Schedule).
-//! This schedule is run in [`RunFixedUpdateLoop`](bevy_app::RunFixedUpdateLoop) near the start of each frame,
-//! via the [`run_fixed_update_schedule`] exclusive system.
-//!
-//! This schedule will be run a number of times each frame,
-//! equal to the accumulated divided by the period resource, rounded down,
-//! as tracked in the [`FixedTime`] resource.
-//! Unused time will be carried over.
-//!
-//! This does not guarantee that the time elapsed between executions is exact,
-//! and systems in this schedule can run 0, 1 or more times on any given frame.
-//!
-//! For example, a system with a fixed timestep run criteria of 120 times per second will run
-//! two times during a ~16.667ms frame, once during a ~8.333ms frame, and once every two frames
-//! with ~4.167ms frames. However, the same criteria may not result in exactly 8.333ms passing
-//! between each execution.
-//!
-//! When using fixed time steps, it is advised not to rely on [`Time::delta`] or any of it's
-//! variants for game simulation, but rather use the value of [`FixedTime`] instead.
-
-use crate::Time;
-use bevy_app::FixedUpdate;
-use bevy_ecs::world::World;
-
-/// Ticks the [`FixedTime`] resource then runs the [`FixedUpdate`].
-pub fn run_fixed_update_schedule(world: &mut World) {
-    // Run the schedule until we run out of accumulated time
-    let _ = world.try_schedule_scope(FixedUpdate, |world, schedule| {
-        while world.resource_mut::<Time>().expend_fixed() {
-            schedule.run(world);
-        }
-    });
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn fixed_time_starts_at_zero() {
-        let new_time = FixedTime::new_from_secs(42.);
-        assert_eq!(new_time.accumulated(), Duration::ZERO);
-
-        let default_time = FixedTime::default();
-        assert_eq!(default_time.accumulated(), Duration::ZERO);
-    }
-
-    #[test]
-    fn fixed_time_ticks_up() {
-        let mut fixed_time = FixedTime::default();
-        fixed_time.tick(Duration::from_secs(1));
-        assert_eq!(fixed_time.accumulated(), Duration::from_secs(1));
-    }
-
-    #[test]
-    fn enough_accumulated_time_is_required() {
-        let mut fixed_time = FixedTime::new(Duration::from_secs(2));
-        fixed_time.tick(Duration::from_secs(1));
-        assert!(fixed_time.expend().is_err());
-        assert_eq!(fixed_time.accumulated(), Duration::from_secs(1));
-
-        fixed_time.tick(Duration::from_secs(1));
-        assert!(fixed_time.expend().is_ok());
-        assert_eq!(fixed_time.accumulated(), Duration::ZERO);
-    }
-
-    #[test]
-    fn repeatedly_expending_time() {
-        let mut fixed_time = FixedTime::new(Duration::from_secs(1));
-        fixed_time.tick(Duration::from_secs_f32(3.2));
-        assert!(fixed_time.expend().is_ok());
-        assert!(fixed_time.expend().is_ok());
-        assert!(fixed_time.expend().is_ok());
-        assert!(fixed_time.expend().is_err());
-    }
-}
diff --git a/crates/bevy_time/src/lib.rs b/crates/bevy_time/src/lib.rs
index f94e399633713..807927aba22dc 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -2,7 +2,6 @@
 
 /// Common run conditions
 pub mod common_conditions;
-pub mod fixed_timestep;
 mod stopwatch;
 #[allow(clippy::module_inception)]
 mod time;
@@ -26,7 +25,7 @@ pub mod prelude {
 use bevy_app::{prelude::*, RunFixedUpdateLoop};
 use bevy_ecs::prelude::*;
 
-use crate::fixed_timestep::run_fixed_update_schedule;
+use crate::time::run_fixed_update_schedule;
 
 /// Adds time functionality to Apps.
 #[derive(Default)]
diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index 77553a6fc4907..8bec2704c57c6 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -1,6 +1,7 @@
-use bevy_ecs::{reflect::ReflectResource, system::Resource};
+use bevy_ecs::{reflect::ReflectResource, system::Resource, world::World};
 use bevy_reflect::{FromReflect, Reflect};
 use bevy_utils::{Duration, Instant};
+use bevy_app::FixedUpdate;
 
 use crate::clock::Clock;
 
@@ -739,4 +740,54 @@ mod tests {
         );
         assert_eq!(time.raw_elapsed(), third_update_instant - start_instant);
     }
+
+    #[test]
+    fn fixed_time_starts_at_zero() {
+        let start_instant = Instant::now();
+
+        let time = Time::new(start_instant);
+
+        assert_eq!(time.fixed_accumulated, Duration::ZERO);
+    }
+
+    #[test]
+    fn fixed_time_ticks_up() {
+        let start_instant = Instant::now();
+        let mut time = Time::new(start_instant);
+        time.set_maximum_delta(None);
+
+        time.update_with_instant(start_instant + Duration::from_secs(1));
+        assert_eq!(time.fixed_accumulated, Duration::from_secs(1));
+    }
+
+    #[test]
+    fn enough_accumulated_time_is_required() {
+        let start_instant = Instant::now();
+        let mut time = Time::new(start_instant);
+        time.set_maximum_delta(None);
+        time.set_fixed_period(Duration::from_secs(2));
+
+        time.update_with_instant(start_instant + Duration::from_secs(1));
+        assert_eq!(time.expend_fixed(), false);
+        assert_eq!(time.fixed_accumulated, Duration::from_secs(1));
+
+        time.update_with_instant(start_instant + Duration::from_secs(2));
+        assert_eq!(time.expend_fixed(), true);
+        assert_eq!(time.fixed_accumulated, Duration::ZERO);
+        assert_eq!(time.expend_fixed(), false);
+    }
+
+    #[test]
+    fn repeatedly_expending_time() {
+        let start_instant = Instant::now();
+        let mut time = Time::new(start_instant);
+        time.set_maximum_delta(None);
+        time.set_fixed_period(Duration::from_secs(1));
+
+        time.update_with_instant(start_instant + Duration::new(3, 200_000_000));
+        assert_eq!(time.expend_fixed(), true);
+        assert_eq!(time.expend_fixed(), true);
+        assert_eq!(time.expend_fixed(), true);
+        assert_eq!(time.expend_fixed(), false);
+    }
 }

From d4e1dd5b1771b2559277f6eb038abb65d234761e Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 14:25:55 +0000
Subject: [PATCH 12/16] Add back default maximum delta

---
 crates/bevy_time/src/time.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index 8bec2704c57c6..c8a99bc09c9aa 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -32,7 +32,7 @@ impl Default for Time {
             last_update: None,
             paused: false,
             relative_speed: 1.0,
-            maximum_delta: None, // XXX
+            maximum_delta: Some(Duration::from_millis(333)), // XXX: From Unity, maybe we should do better
             fixed_accumulated: Duration::ZERO,
             fixed_period: Duration::from_secs_f32(1. / 60.), // XXX
             raw_clock: Clock::default(),

From 4650d8adbfc0fb06ca78026bc23491b2de4d81fc Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 14:26:57 +0000
Subject: [PATCH 13/16] Fix tests again

---
 crates/bevy_time/src/time.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index c8a99bc09c9aa..b5f61abd25720 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -571,6 +571,7 @@ mod tests {
         let start_instant = Instant::now();
 
         let mut time = Time::new(start_instant);
+        time.set_maximum_delta(None);
         time.set_wrap_period(Duration::from_secs(3));
 
         assert_eq!(time.elapsed_seconds_wrapped(), 0.0);
@@ -592,6 +593,7 @@ mod tests {
     fn relative_speed_test() {
         let start_instant = Instant::now();
         let mut time = Time::new(start_instant);
+        time.set_maximum_delta(None);
 
         let first_update_instant = Instant::now();
         time.update_with_instant(first_update_instant);

From 94391506a8acc06652c9d449fcf9e5812456719d Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 14:27:58 +0000
Subject: [PATCH 14/16] Reorder methods a bit

---
 crates/bevy_time/src/clock.rs | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_time/src/clock.rs b/crates/bevy_time/src/clock.rs
index 8e6b532ee0c99..cf927eedb769d 100644
--- a/crates/bevy_time/src/clock.rs
+++ b/crates/bevy_time/src/clock.rs
@@ -49,6 +49,19 @@ impl Clock {
         self.advance_by(elapsed - self.elapsed)
     }
 
+    pub fn wrap_period(&self) -> Duration {
+        Duration::from_secs(self.wrap_seconds)
+    }
+
+    pub fn set_wrap_period(&mut self, wrap_period: Duration) {
+        assert!(!wrap_period.is_zero(), "division by zero");
+        assert_eq!(wrap_period.subsec_nanos(), 0, "wrap period must be integral seconds");
+        self.wrap_seconds = wrap_period.as_secs();
+        self.elapsed_wrapped = Duration::new(self.elapsed.as_secs() % self.wrap_seconds, self.elapsed.subsec_nanos());
+        self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
+        self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();        
+    }
+
     pub fn delta(&self) -> Duration {
         self.delta
     }
@@ -84,19 +97,6 @@ impl Clock {
     pub fn elapsed_seconds_wrapped_f64(&self) -> f64 {
         self.elapsed_seconds_wrapped_f64
     }
-
-    pub fn wrap_period(&self) -> Duration {
-        Duration::from_secs(self.wrap_seconds)
-    }
-
-    pub fn set_wrap_period(&mut self, wrap_period: Duration) {
-        assert!(!wrap_period.is_zero(), "division by zero");
-        assert_eq!(wrap_period.subsec_nanos(), 0, "wrap period must be integral seconds");
-        self.wrap_seconds = wrap_period.as_secs();
-        self.elapsed_wrapped = Duration::new(self.elapsed.as_secs() % self.wrap_seconds, self.elapsed.subsec_nanos());
-        self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
-        self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();        
-    }
 }
 
 impl Default for Clock {

From 03dd2535c36fc119c54ca1cc887496b294c48cbd Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 14:37:11 +0000
Subject: [PATCH 15/16] Change logic to keep all times as zero on first update

---
 crates/bevy_time/src/time.rs | 71 +++++++++++++++++++-----------------
 1 file changed, 37 insertions(+), 34 deletions(-)

diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index b5f61abd25720..2d526f6e5fa7c 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -114,6 +114,11 @@ impl Time {
     /// }
     /// ```
     pub fn update_with_instant(&mut self, instant: Instant) {
+        if self.last_update.is_none() {
+            self.first_update = Some(instant);
+            self.last_update = Some(instant);
+            return;
+        }
         let raw_delta = instant - self.last_update.unwrap_or(self.startup);
         self.raw_clock.advance_by(raw_delta);
         let scaled_delta = if self.paused {
@@ -132,12 +137,6 @@ impl Time {
         self.virtual_clock.advance_by(delta);
         self.fixed_accumulated += delta;
 
-        if self.last_update.is_none() {
-            self.first_update = Some(instant);
-            // on first actual update, zero out delta so we do not get a big jump due to startup systems
-            self.raw_clock.advance_by(Duration::ZERO);
-            self.virtual_clock.advance_by(Duration::ZERO);
-        }
         self.last_update = Some(instant);
         self.current_clock = self.virtual_clock;
     }
@@ -498,23 +497,23 @@ mod tests {
         assert_eq!(time.raw_delta(), Duration::ZERO);
         assert_eq!(time.raw_delta_seconds(), 0.0);
         assert_eq!(time.raw_delta_seconds_f64(), 0.0);
-        assert_eq!(time.elapsed(), first_update_instant - start_instant,);
+        assert_eq!(time.elapsed(), Duration::ZERO);
         assert_eq!(
             time.elapsed_seconds(),
-            (first_update_instant - start_instant).as_secs_f32(),
+            0.0
         );
         assert_eq!(
             time.elapsed_seconds_f64(),
-            (first_update_instant - start_instant).as_secs_f64(),
+            0.0
         );
-        assert_eq!(time.raw_elapsed(), first_update_instant - start_instant,);
+        assert_eq!(time.raw_elapsed(), Duration::ZERO);
         assert_eq!(
             time.raw_elapsed_seconds(),
-            (first_update_instant - start_instant).as_secs_f32(),
+            0.0
         );
         assert_eq!(
             time.raw_elapsed_seconds_f64(),
-            (first_update_instant - start_instant).as_secs_f64(),
+            0.0
         );
 
         // Update `time` again and check results.
@@ -546,23 +545,23 @@ mod tests {
             time.raw_delta_seconds_f64(),
             (second_update_instant - first_update_instant).as_secs_f64(),
         );
-        assert_eq!(time.elapsed(), second_update_instant - start_instant,);
+        assert_eq!(time.elapsed(), second_update_instant - first_update_instant,);
         assert_eq!(
             time.elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
+            (second_update_instant - first_update_instant).as_secs_f32(),
         );
         assert_eq!(
             time.elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
+            (second_update_instant - first_update_instant).as_secs_f64(),
         );
-        assert_eq!(time.raw_elapsed(), second_update_instant - start_instant,);
+        assert_eq!(time.raw_elapsed(), second_update_instant - first_update_instant,);
         assert_eq!(
             time.raw_elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
+            (second_update_instant - first_update_instant).as_secs_f32(),
         );
         assert_eq!(
             time.raw_elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
+            (second_update_instant - first_update_instant).as_secs_f64(),
         );
     }
 
@@ -573,6 +572,7 @@ mod tests {
         let mut time = Time::new(start_instant);
         time.set_maximum_delta(None);
         time.set_wrap_period(Duration::from_secs(3));
+        time.update_with_instant(start_instant);
 
         assert_eq!(time.elapsed_seconds_wrapped(), 0.0);
 
@@ -627,23 +627,23 @@ mod tests {
             time.raw_delta_seconds_f64(),
             (second_update_instant - first_update_instant).as_secs_f64(),
         );
-        assert_eq!(time.elapsed(), second_update_instant - start_instant,);
+        assert_eq!(time.elapsed(), second_update_instant - first_update_instant,);
         assert_eq!(
             time.elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
+            (second_update_instant - first_update_instant).as_secs_f32(),
         );
         assert_eq!(
             time.elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
+            (second_update_instant - first_update_instant).as_secs_f64(),
         );
-        assert_eq!(time.raw_elapsed(), second_update_instant - start_instant,);
+        assert_eq!(time.raw_elapsed(), second_update_instant - first_update_instant,);
         assert_eq!(
             time.raw_elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
+            (second_update_instant - first_update_instant).as_secs_f32(),
         );
         assert_eq!(
             time.raw_elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
+            (second_update_instant - first_update_instant).as_secs_f64(),
         );
 
         // Make app time advance at 2x the rate of your system clock.
@@ -668,27 +668,27 @@ mod tests {
         assert_eq!(time.raw_delta_seconds_f64(), elapsed.as_secs_f64());
         assert_eq!(
             time.elapsed(),
-            second_update_instant - start_instant + elapsed.mul_f32(2.0),
+            second_update_instant - first_update_instant + elapsed.mul_f32(2.0),
         );
         assert_eq!(
             time.elapsed_seconds(),
-            (second_update_instant - start_instant + elapsed.mul_f32(2.0)).as_secs_f32(),
+            (second_update_instant - first_update_instant + elapsed.mul_f32(2.0)).as_secs_f32(),
         );
         assert_eq!(
             time.elapsed_seconds_f64(),
-            (second_update_instant - start_instant + elapsed.mul_f32(2.0)).as_secs_f64(),
+            (second_update_instant - first_update_instant + elapsed.mul_f32(2.0)).as_secs_f64(),
         );
         assert_eq!(
             time.raw_elapsed(),
-            second_update_instant - start_instant + elapsed,
+            second_update_instant - first_update_instant + elapsed,
         );
         assert_eq!(
             time.raw_elapsed_seconds(),
-            (second_update_instant - start_instant + elapsed).as_secs_f32(),
+            (second_update_instant - first_update_instant + elapsed).as_secs_f32(),
         );
         assert_eq!(
             time.raw_elapsed_seconds_f64(),
-            (second_update_instant - start_instant + elapsed).as_secs_f64(),
+            (second_update_instant - first_update_instant + elapsed).as_secs_f64(),
         );
     }
 
@@ -718,8 +718,8 @@ mod tests {
             time.raw_delta(),
             second_update_instant - first_update_instant,
         );
-        assert_eq!(time.elapsed(), first_update_instant - start_instant);
-        assert_eq!(time.raw_elapsed(), second_update_instant - start_instant);
+        assert_eq!(time.elapsed(), first_update_instant - first_update_instant);
+        assert_eq!(time.raw_elapsed(), second_update_instant - first_update_instant);
 
         time.unpause();
 
@@ -738,9 +738,9 @@ mod tests {
         );
         assert_eq!(
             time.elapsed(),
-            (third_update_instant - second_update_instant) + (first_update_instant - start_instant),
+            (third_update_instant - second_update_instant) + (first_update_instant - first_update_instant),
         );
-        assert_eq!(time.raw_elapsed(), third_update_instant - start_instant);
+        assert_eq!(time.raw_elapsed(), third_update_instant - first_update_instant);
     }
 
     #[test]
@@ -757,6 +757,7 @@ mod tests {
         let start_instant = Instant::now();
         let mut time = Time::new(start_instant);
         time.set_maximum_delta(None);
+        time.update_with_instant(start_instant);
 
         time.update_with_instant(start_instant + Duration::from_secs(1));
         assert_eq!(time.fixed_accumulated, Duration::from_secs(1));
@@ -768,6 +769,7 @@ mod tests {
         let mut time = Time::new(start_instant);
         time.set_maximum_delta(None);
         time.set_fixed_period(Duration::from_secs(2));
+        time.update_with_instant(start_instant);
 
         time.update_with_instant(start_instant + Duration::from_secs(1));
         assert_eq!(time.expend_fixed(), false);
@@ -785,6 +787,7 @@ mod tests {
         let mut time = Time::new(start_instant);
         time.set_maximum_delta(None);
         time.set_fixed_period(Duration::from_secs(1));
+        time.update_with_instant(start_instant);
 
         time.update_with_instant(start_instant + Duration::new(3, 200_000_000));
         assert_eq!(time.expend_fixed(), true);

From 3a779f3a9b636d547f27b0ba383f7707ffcacca4 Mon Sep 17 00:00:00 2001
From: Nuutti Kotivuori <naked@iki.fi>
Date: Sat, 24 Jun 2023 14:52:28 +0000
Subject: [PATCH 16/16] Add set_maximum_fixed_ticks

---
 crates/bevy_time/src/time.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index 2d526f6e5fa7c..100a8ee22ecc4 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -347,6 +347,10 @@ impl Time {
     pub fn set_maximum_delta(&mut self, maximum_delta: Option<Duration>) {
         self.maximum_delta = maximum_delta;
     }
+    
+    pub fn set_maximum_fixed_ticks(&mut self, ticks: u32) {
+        self.maximum_delta = Some(self.fixed_period * ticks);
+    }
 
     /// Returns the speed the clock advances relative to your system clock, as [`f32`].
     /// This is known as "time scaling" or "time dilation" in other engines.