From d3d94bf37e989f0927b72ee5b47633efba5a01cd Mon Sep 17 00:00:00 2001
From: JoJoJet <joe102000@gmail.com>
Date: Tue, 26 Jul 2022 20:45:26 -0400
Subject: [PATCH 01/10] add `SubSchedule` API

---
 crates/bevy_app/src/app.rs            |  91 ++++++++++-
 crates/bevy_app/src/lib.rs            |   5 +-
 crates/bevy_app/src/sub_schedule.rs   | 216 ++++++++++++++++++++++++++
 crates/bevy_ecs/macros/src/lib.rs     |  15 ++
 crates/bevy_ecs/src/lib.rs            |   4 +-
 crates/bevy_ecs/src/schedule/label.rs |  12 +-
 6 files changed, 336 insertions(+), 7 deletions(-)
 create mode 100644 crates/bevy_app/src/sub_schedule.rs

diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index ebdd2ee0df54a..236eef9bebaed 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -1,11 +1,15 @@
-use crate::{CoreStage, Plugin, PluginGroup, PluginGroupBuilder, StartupSchedule, StartupStage};
+use crate::{
+    CoreStage, IntoSubSchedule, Plugin, PluginGroup, PluginGroupBuilder, StartupSchedule,
+    StartupStage, SubSchedules,
+};
 pub use bevy_derive::AppLabel;
 use bevy_ecs::{
+    change_detection::Mut,
     event::{Event, Events},
     prelude::{FromWorld, IntoExclusiveSystem},
     schedule::{
-        IntoSystemDescriptor, Schedule, ShouldRun, Stage, StageLabel, State, StateData, SystemSet,
-        SystemStage,
+        IntoSystemDescriptor, Schedule, ScheduleLabel, ShouldRun, Stage, StageLabel, State,
+        StateData, SystemSet, SystemStage,
     },
     system::Resource,
     world::World,
@@ -311,6 +315,87 @@ impl App {
         self
     }
 
+    /// Adds a [`SubSchedule`](crate::SubSchedule) to the app.
+    ///
+    /// If a [label](bevy_ecs::schedule::ScheduleLabel) has been applied to it,
+    /// it can be accessed in the resource [`SubSchedules`].
+    ///
+    /// # Examples
+    /// ```
+    /// # use bevy_app::prelude::*;
+    /// # use bevy_ecs::prelude::*;
+    /// # let mut app = App::new();
+    /// # fn foo_system() {}
+    /// # fn bar_system() {}
+    /// #
+    /// // Define a label for the a schedule.
+    /// #[derive(ScheduleLabel)]
+    /// struct MySched;
+    ///
+    /// // Add a new sub-schedule. If the schedule only needs one stage,
+    /// // you can avoid some overhead by adding the stage directly.
+    /// app.add_sub_schedule(
+    ///     SystemStage::parallel()
+    ///         .with_system(foo_system)
+    ///         .with_system(bar_system)
+    ///         .label(MySched),
+    /// );
+    /// ```
+    #[track_caller]
+    pub fn add_sub_schedule(&mut self, sched: impl IntoSubSchedule) -> &mut Self {
+        crate::sub_schedule::add_to_app(self, IntoSubSchedule::into_sched(sched));
+        self
+    }
+
+    /// Allows you to modify a [`SubSchedule`](crate::SubSchedule) by executing a closure on it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bevy_app::prelude::*;
+    /// # use bevy_ecs::prelude::*;
+    /// #
+    /// # #[derive(ScheduleLabel)]
+    /// # struct FixedUpdate;
+    /// #
+    /// # let mut app = App::new();
+    /// # app.add_sub_schedule(
+    /// #   Schedule::default()
+    /// #       .with_stage(CoreStage::Update, SystemStage::parallel())
+    /// #       .label(FixedUpdate),
+    /// # );
+    /// # fn my_system() {}
+    /// #
+    /// // Access a previously-added sub-schedule and add a system to it.
+    /// app.sub_schedule(FixedUpdate, |sched: &mut Schedule| {
+    ///     sched.add_system_to_stage(CoreStage::Update, my_system);
+    /// });
+    /// ```
+    ///
+    /// # Panics
+    /// If `label` refers to a non-existent `SubSchedule`, or if it is not of type `S`.
+    pub fn sub_schedule<S: Stage, F>(&mut self, label: impl ScheduleLabel, f: F) -> &mut Self
+    where
+        F: FnOnce(&mut S),
+    {
+        #[inline(never)]
+        fn panic(label: impl Debug, ty: impl Debug) -> ! {
+            panic!("there is no sub-schedule labeled '{label:?}', or it does not match the type `{ty:?}`");
+        }
+
+        let label = label.as_label();
+
+        // Make sure the resource is initialized, so we get a more helpful panic message.
+        let mut schedules: Mut<SubSchedules> =
+            self.world.get_resource_or_insert_with(Default::default);
+        let sched: &mut S = match schedules.get_mut(label) {
+            Some(x) => x,
+            None => panic(label, std::any::type_name::<S>()),
+        };
+        f(sched);
+        self
+    }
+
     /// Adds a system to the [update stage](Self::add_default_stages) of the app's [`Schedule`].
     ///
     /// Refer to the [system module documentation](bevy_ecs::system) to see how a system
diff --git a/crates/bevy_app/src/lib.rs b/crates/bevy_app/src/lib.rs
index c0a9c68f79c3f..604da8e9c9cb9 100644
--- a/crates/bevy_app/src/lib.rs
+++ b/crates/bevy_app/src/lib.rs
@@ -6,6 +6,7 @@ mod app;
 mod plugin;
 mod plugin_group;
 mod schedule_runner;
+mod sub_schedule;
 
 #[cfg(feature = "bevy_ci_testing")]
 mod ci_testing;
@@ -15,12 +16,14 @@ pub use bevy_derive::DynamicPlugin;
 pub use plugin::*;
 pub use plugin_group::*;
 pub use schedule_runner::*;
+pub use sub_schedule::*;
 
 #[allow(missing_docs)]
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        app::App, CoreStage, DynamicPlugin, Plugin, PluginGroup, StartupSchedule, StartupStage,
+        app::App, CoreStage, DynamicPlugin, IntoSubSchedule, Plugin, PluginGroup, StartupSchedule,
+        StartupStage,
     };
 }
 
diff --git a/crates/bevy_app/src/sub_schedule.rs b/crates/bevy_app/src/sub_schedule.rs
new file mode 100644
index 0000000000000..c29f9e73ed5a0
--- /dev/null
+++ b/crates/bevy_app/src/sub_schedule.rs
@@ -0,0 +1,216 @@
+use std::fmt::Debug;
+
+use bevy_ecs::{
+    change_detection::Mut,
+    schedule::{ScheduleLabel, ScheduleLabelId, Stage, StageLabel, StageLabelId},
+    system::IntoExclusiveSystem,
+    world::World,
+};
+use bevy_utils::HashMap;
+
+use crate::App;
+
+/// Methods for converting a schedule into a [sub-Schedule](SubSchedule) descriptor.
+pub trait IntoSubSchedule: Sized {
+    /// The wrapped schedule type.
+    type Sched: Stage;
+    /// The type that controls the behaviour of the exclusive system
+    /// which runs [`SubSchedule`]s of this type.
+    type Runner: FnMut(&mut Self::Sched, &mut World) + Send + Sync + 'static;
+
+    /// Applies the specified label to the current schedule.
+    /// This means it will be accessible in the [`SubSchedules`] resource after
+    /// being added to the [`App`].
+    fn label(self, label: impl ScheduleLabel) -> SubSchedule<Self::Sched, Self::Runner> {
+        let mut sub = Self::into_sched(self);
+        sub.label = Some(label.as_label());
+        sub
+    }
+    /// Defines a function that runs the current schedule. It will be inserted into
+    /// an exclusive system within the stage `stage`.
+    ///
+    /// Overwrites any previously set runner or stage.
+    fn with_runner<F>(self, stage: impl StageLabel, f: F) -> SubSchedule<Self::Sched, F>
+    where
+        F: FnMut(&mut Self::Sched, &mut World) + Send + Sync + 'static,
+    {
+        let SubSchedule {
+            schedule, label, ..
+        } = Self::into_sched(self);
+        SubSchedule {
+            schedule,
+            label,
+            runner: Some((stage.as_label(), f)),
+        }
+    }
+
+    /// Performs the conversion. You usually do not need to call this directly.
+    fn into_sched(_: Self) -> SubSchedule<Self::Sched, Self::Runner>;
+}
+
+impl<S: Stage> IntoSubSchedule for S {
+    type Sched = Self;
+    type Runner = fn(&mut Self, &mut World);
+    fn into_sched(schedule: Self) -> SubSchedule<Self, Self::Runner> {
+        SubSchedule {
+            schedule,
+            label: None,
+            runner: None,
+        }
+    }
+}
+
+impl<S: Stage, R> IntoSubSchedule for SubSchedule<S, R>
+where
+    R: FnMut(&mut S, &mut World) + Send + Sync + 'static,
+{
+    type Sched = S;
+    type Runner = R;
+    #[inline]
+    fn into_sched(sched: Self) -> SubSchedule<S, R> {
+        sched
+    }
+}
+
+/// A schedule that may run independently of the main app schedule.
+pub struct SubSchedule<S: Stage, F>
+where
+    F: FnMut(&mut S, &mut World) + Send + Sync + 'static,
+{
+    schedule: S,
+    label: Option<ScheduleLabelId>,
+    runner: Option<(StageLabelId, F)>,
+}
+
+/// A [resource](bevy_ecs::system::Res) that stores all labeled [`SubSchedule`]s.
+#[derive(Default)]
+pub struct SubSchedules {
+    // INVARIANT: A `SubSlot` cannot be removed once added, and is associated with
+    // a single schedule. Even if a slot gets temporarily emptied, it is guaranteed
+    // that the slot will always get refilled by the same exact schedule.
+    map: HashMap<ScheduleLabelId, SubSlot>,
+}
+
+struct SubSlot(Option<Box<dyn Stage>>);
+impl SubSchedules {
+    /// Inserts a new sub-schedule.
+    ///
+    /// # Panics
+    /// If there is already a sub-schedule labeled `label`.
+    #[track_caller]
+    pub fn insert(&mut self, label: impl ScheduleLabel, sched: Box<dyn Stage>) {
+        let label = label.as_label();
+        let old = self.map.insert(label, SubSlot(Some(sched)));
+        if old.is_some() {
+            panic!("there is already a sub-schedule with label '{label:?}'");
+        }
+    }
+
+    /// Temporarily extracts a [`SubSchedule`] from the world, and provides a scope
+    /// that has mutable access to both the schedule and the [`World`].
+    /// At the end of this scope, the sub-schedule is automatically reinserted.
+    ///
+    /// # Panics
+    /// If there is no schedule associated with `label`, or if that schedule
+    /// is currently already extracted.
+    #[track_caller]
+    pub fn extract_scope<F, T>(world: &mut World, label: impl ScheduleLabel, f: F) -> T
+    where
+        F: FnOnce(&mut World, &mut dyn Stage) -> T,
+    {
+        #[inline(never)]
+        fn panic_none(label: impl Debug) -> ! {
+            panic!("there is no sub-schedule with label '{label:?}'")
+        }
+        #[inline(never)]
+        fn panic_extracted(label: impl Debug) -> ! {
+            panic!("cannot extract sub-schedule '{label:?}', as it is currently extracted already")
+        }
+
+        let label = label.as_label();
+
+        // Extract.
+        let mut schedules = world.resource_mut::<Self>();
+        let mut sched = match schedules.map.get_mut(&label) {
+            Some(x) => match x.0.take() {
+                Some(x) => x,
+                None => panic_extracted(label),
+            },
+            None => panic_none(label),
+        };
+
+        // Execute.
+        let val = f(world, sched.as_mut());
+
+        // Re-insert.
+        let mut schedules = world.resource_mut::<Self>();
+        schedules.map.get_mut(&label).unwrap().0 = Some(sched);
+
+        val
+    }
+
+    /// Gets a mutable reference to the sub-schedule identified by `label`.
+    ///
+    /// # Panics
+    /// If the schedule is currently [extracted](#method.extract_scope).
+    pub fn get_mut<S: Stage>(&mut self, label: impl ScheduleLabel) -> Option<&mut S> {
+        #[cold]
+        fn panic(label: impl Debug) -> ! {
+            panic!("cannot get sub-schedule '{label:?}', as it is currently extracted")
+        }
+
+        let label = label.as_label();
+        let sched = match self.map.get_mut(&label)?.0.as_deref_mut() {
+            Some(x) => x,
+            None => panic(label),
+        };
+        sched.downcast_mut()
+    }
+}
+
+#[track_caller]
+pub(crate) fn add_to_app<S: Stage>(app: &mut App, schedule: impl IntoSubSchedule<Sched = S>) {
+    let SubSchedule {
+        mut schedule,
+        label,
+        runner,
+    } = IntoSubSchedule::into_sched(schedule);
+
+    // If it has a label, insert it to the public resource.
+    if let Some(label) = label {
+        let mut res: Mut<SubSchedules> = app.world.get_resource_or_insert_with(Default::default);
+        res.insert(label, Box::new(schedule));
+
+        if let Some((stage, mut runner)) = runner {
+            // Driver which extracts the schedule from the world and runs it.
+            let driver = move |w: &mut World| {
+                SubSchedules::extract_scope(w, label, |w, sched| {
+                    let sched = if let Some(s) = sched.downcast_mut::<S>() {
+                        s
+                    } else {
+                        #[cfg(debug_assertions)]
+                        unreachable!("the sub-schedule '{label:?}' somehow changed type after being inserted!");
+                        // SAFETY: Due to the invariant on `SubSchedules`, we can be sure that
+                        // `sched` is the same instance that we inserted.
+                        // Thus, we can rely on its type matching `S`.
+                        #[cfg(not(debug_assertions))]
+                        unsafe {
+                            std::hint::unreachable_unchecked()
+                        }
+                    };
+                    runner(sched, w);
+                });
+            };
+            app.add_system_to_stage(stage, driver.exclusive_system());
+        }
+    } else if let Some((stage, mut runner)) = runner {
+        // If there's no label, then the schedule isn't visible publicly.
+        // We can just store it locally
+        let driver = move |w: &mut World| {
+            runner(&mut schedule, w);
+        };
+        app.add_system_to_stage(stage, driver.exclusive_system());
+    } else {
+        panic!("inserted sub-schedule can never be accessed, as it has neither a label nor a runner function")
+    }
+}
diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index 68023e315ddb0..1fa57040e4a57 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -492,6 +492,21 @@ pub fn derive_run_criteria_label(input: TokenStream) -> TokenStream {
     derive_label(input, &trait_path, "run_criteria_label")
 }
 
+/// Generates an impl of the `ScheduleLabel` trait.
+///
+/// This works only for unit structs, or enums with only unit variants.
+/// You may force a struct or variant to behave as if it were fieldless with `#[schedule_label(ignore_fields)]`.
+#[proc_macro_derive(ScheduleLabel, attributes(schedule_label))]
+pub fn derive_schedule_label(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let mut trait_path = bevy_ecs_path();
+    trait_path.segments.push(format_ident!("schedule").into());
+    trait_path
+        .segments
+        .push(format_ident!("ScheduleLabel").into());
+    derive_label(input, &trait_path, "schedule_label")
+}
+
 pub(crate) fn bevy_ecs_path() -> syn::Path {
     BevyManifest::default().get_path("bevy_ecs")
 }
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index cafacc2a2d929..1b7b67bb73023 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -35,8 +35,8 @@ pub mod prelude {
         query::{Added, AnyOf, ChangeTrackers, Changed, Or, QueryState, With, Without},
         schedule::{
             AmbiguitySetLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion,
-            RunCriteria, RunCriteriaDescriptorCoercion, RunCriteriaLabel, Schedule, Stage,
-            StageLabel, State, SystemLabel, SystemSet, SystemStage,
+            RunCriteria, RunCriteriaDescriptorCoercion, RunCriteriaLabel, Schedule, ScheduleLabel,
+            Stage, StageLabel, State, SystemLabel, SystemSet, SystemStage,
         },
         system::{
             Commands, In, IntoChainSystem, IntoExclusiveSystem, IntoSystem, Local, NonSend,
diff --git a/crates/bevy_ecs/src/schedule/label.rs b/crates/bevy_ecs/src/schedule/label.rs
index c9bccf8303084..5a890891ccb54 100644
--- a/crates/bevy_ecs/src/schedule/label.rs
+++ b/crates/bevy_ecs/src/schedule/label.rs
@@ -1,4 +1,6 @@
-pub use bevy_ecs_macros::{AmbiguitySetLabel, RunCriteriaLabel, StageLabel, SystemLabel};
+pub use bevy_ecs_macros::{
+    AmbiguitySetLabel, RunCriteriaLabel, ScheduleLabel, StageLabel, SystemLabel,
+};
 use bevy_utils::define_label;
 
 define_label!(
@@ -25,3 +27,11 @@ define_label!(
     /// Strongly-typed identifier for a [`RunCriteriaLabel`].
     RunCriteriaLabelId,
 );
+
+// note: this type won't be necessary come stageless, but we need it for now.
+define_label!(
+    /// A strongly-typed class of labels used to identify a [`Schedule`](crate::schedule::Schedule).
+    ScheduleLabel,
+    /// Strongly-typed identifier for a [`ScheduleLabel`].
+    ScheduleLabelId,
+);

From 867e7dd4d36ac4952fdfb54695e4a6b2e7166227 Mon Sep 17 00:00:00 2001
From: JoJoJet <joe102000@gmail.com>
Date: Tue, 26 Jul 2022 22:54:13 -0400
Subject: [PATCH 02/10] use sub-schedules for fixed timestep

---
 crates/bevy_time/src/fixed_timestep.rs | 331 ++++++++++++-------------
 crates/bevy_time/src/lib.rs            |   3 +-
 2 files changed, 153 insertions(+), 181 deletions(-)

diff --git a/crates/bevy_time/src/fixed_timestep.rs b/crates/bevy_time/src/fixed_timestep.rs
index 78fdfca797c50..5dfede95e8e63 100644
--- a/crates/bevy_time/src/fixed_timestep.rs
+++ b/crates/bevy_time/src/fixed_timestep.rs
@@ -1,17 +1,109 @@
-use crate::Time;
+use std::fmt::Debug;
+
+use bevy_app::{App, CoreStage, IntoSubSchedule};
 use bevy_ecs::{
-    archetype::ArchetypeComponentId,
-    component::ComponentId,
-    query::Access,
-    schedule::ShouldRun,
-    system::{IntoSystem, Res, ResMut, System},
+    change_detection::Mut,
+    schedule::{ScheduleLabel, ScheduleLabelId, Stage, StageLabel},
     world::World,
 };
 use bevy_utils::HashMap;
-use std::borrow::Cow;
+
+use crate::Time;
+
+/// Extends [`App`] with methods for constructing schedules with a fixed time-step.
+pub trait TimestepAppExt {
+    /// Adds a new fixed time-step schedule to the stage identified by `stage_label`.
+    /// If `timestep` has a label, it is applied to the schedule as well.
+    ///
+    /// # Panics
+    /// If there is already a fixed schedule identified by `label`.
+    fn add_fixed_schedule_to_stage<S: Stage>(
+        &mut self,
+        stage_label: impl StageLabel,
+        timestep: FixedTimestep,
+        schedule: S,
+    ) -> &mut Self;
+    /// Adds a new fixed time-step schedule to [`CoreStage::Update`].
+    /// If `timestep` has a label, it is applied to the schedule as well.
+    ///
+    /// # Panics
+    /// If there is already a fixed schedule identified by `label`.
+    fn add_fixed_schedule(&mut self, timestep: FixedTimestep, schedule: impl Stage) -> &mut Self {
+        self.add_fixed_schedule_to_stage(CoreStage::Update, timestep, schedule)
+    }
+}
+
+impl TimestepAppExt for App {
+    #[track_caller]
+    fn add_fixed_schedule_to_stage<S: Stage>(
+        &mut self,
+        stage: impl StageLabel,
+        FixedTimestep { label, step }: FixedTimestep,
+        schedule: S,
+    ) -> &mut Self {
+        // If it has a label, add it to the resource so it can be modified or peeked later.
+        if let Some(label) = label {
+            let mut timesteps: Mut<FixedTimesteps> =
+                self.world.get_resource_or_insert_with(Default::default);
+            let state = FixedTimestepState {
+                step,
+                accumulator: 0.0,
+            };
+
+            // Insert the state into the map.
+            // Panic if there already was one.
+            if timesteps.insert(label, state).is_some() {
+                #[inline(never)]
+                #[track_caller]
+                fn panic(label: impl Debug) -> ! {
+                    panic!("there is already a fixed timestep labeled '{label:?}'");
+                }
+                panic(label)
+            }
+
+            let runner = move |s: &mut S, w: &mut World| {
+                let mut state = *w.resource::<FixedTimesteps>().get(label).unwrap();
+
+                // Core looping functionality.
+                let time = w.resource::<Time>();
+                state.accumulator += time.delta_seconds_f64();
+                while state.accumulator > state.step {
+                    state.accumulator -= state.step;
+
+                    s.run(w);
+                }
+
+                // Update the resource (we've only been operating on a copy).
+                w.resource_mut::<FixedTimesteps>().insert(label, state);
+            };
+            self.add_sub_schedule(schedule.label(label).with_runner(stage, runner));
+        }
+        // If there's no label, we can keep everything local
+        // since there's no way to refer to the schedule again anyway.
+        else {
+            let mut state = FixedTimestepState {
+                step,
+                accumulator: 0.0,
+            };
+            let runner = move |sched: &mut S, w: &mut World| {
+                // Core looping functionality.
+                let time = w.resource::<Time>();
+                state.accumulator += time.delta_seconds_f64();
+                while state.accumulator > state.step {
+                    state.accumulator -= state.step;
+
+                    sched.run(w);
+                }
+            };
+            self.add_sub_schedule(schedule.with_runner(stage, runner));
+        }
+
+        self
+    }
+}
 
 /// The internal state of each [`FixedTimestep`].
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
 pub struct FixedTimestepState {
     step: f64,
     accumulator: f64,
@@ -39,191 +131,73 @@ impl FixedTimestepState {
     }
 }
 
-/// A global resource that tracks the individual [`FixedTimestepState`]s
-/// for every labeled [`FixedTimestep`].
+/// A global resource that tracks the state for every labeled [`FixedTimestep`].
 #[derive(Default)]
 pub struct FixedTimesteps {
-    fixed_timesteps: HashMap<String, FixedTimestepState>,
+    fixed_timesteps: HashMap<ScheduleLabelId, FixedTimestepState>,
 }
 
 impl FixedTimesteps {
     /// Gets the [`FixedTimestepState`] for a given label.
-    pub fn get(&self, name: &str) -> Option<&FixedTimestepState> {
-        self.fixed_timesteps.get(name)
+    pub fn get(&self, label: impl ScheduleLabel) -> Option<&FixedTimestepState> {
+        self.fixed_timesteps.get(&label.as_label())
+    }
+
+    fn insert(
+        &mut self,
+        label: impl ScheduleLabel,
+        state: FixedTimestepState,
+    ) -> Option<FixedTimestepState> {
+        self.fixed_timesteps.insert(label.as_label(), state)
     }
 }
 
-/// A system run criteria that enables systems or stages to run at a fixed timestep between executions.
+/// Enables a sub-schedule to run at a fixed timestep between executions.
 ///
 /// This does not guarantee that the time elapsed between executions is exactly the provided
 /// fixed timestep, but will guarantee that the execution will run multiple times per game tick
 /// until the number of repetitions is as expected.
 ///
-/// For example, a system with a fixed timestep run criteria of 120 times per second will run
+/// For example, a schedule with a fixed timestep 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 this run criteria, it is advised not to rely on [`Time::delta`] or any of it's
+/// When using this pattern, it is advised not to rely on [`Time::delta`] or any of its
 /// variants for game simulation, but rather use the constant time delta used to initialize the
 /// [`FixedTimestep`] instead.
 ///
 /// For more fine tuned information about the execution status of a given fixed timestep,
 /// use the [`FixedTimesteps`] resource.
 pub struct FixedTimestep {
-    state: LocalFixedTimestepState,
-    internal_system: Box<dyn System<In = (), Out = ShouldRun>>,
+    label: Option<ScheduleLabelId>,
+    step: f64,
 }
 
 impl Default for FixedTimestep {
     fn default() -> Self {
-        Self {
-            state: LocalFixedTimestepState::default(),
-            internal_system: Box::new(IntoSystem::into_system(Self::prepare_system(
-                Default::default(),
-            ))),
-        }
+        Self::steps_per_second(60.0)
     }
 }
 
 impl FixedTimestep {
     /// Creates a [`FixedTimestep`] that ticks once every `step` seconds.
     pub fn step(step: f64) -> Self {
-        Self {
-            state: LocalFixedTimestepState {
-                step,
-                ..Default::default()
-            },
-            ..Default::default()
-        }
+        Self { step, label: None }
     }
 
     /// Creates a [`FixedTimestep`] that ticks once every `rate` times per second.
     pub fn steps_per_second(rate: f64) -> Self {
-        Self {
-            state: LocalFixedTimestepState {
-                step: 1.0 / rate,
-                ..Default::default()
-            },
-            ..Default::default()
-        }
+        Self::step(rate.recip())
     }
 
     /// Sets the label for the timestep. Setting a label allows a timestep
     /// to be observed by the global [`FixedTimesteps`] resource.
     #[must_use]
-    pub fn with_label(mut self, label: &str) -> Self {
-        self.state.label = Some(label.to_string());
+    pub fn with_label(mut self, label: impl ScheduleLabel) -> Self {
+        self.label = Some(label.as_label());
         self
     }
-
-    fn prepare_system(
-        mut state: LocalFixedTimestepState,
-    ) -> impl FnMut(Res<Time>, ResMut<FixedTimesteps>) -> ShouldRun {
-        move |time, mut fixed_timesteps| {
-            let should_run = state.update(&time);
-            if let Some(ref label) = state.label {
-                let res_state = fixed_timesteps.fixed_timesteps.get_mut(label).unwrap();
-                res_state.step = state.step;
-                res_state.accumulator = state.accumulator;
-            }
-
-            should_run
-        }
-    }
-}
-
-#[derive(Clone)]
-struct LocalFixedTimestepState {
-    label: Option<String>, // TODO: consider making this a TypedLabel
-    step: f64,
-    accumulator: f64,
-    looping: bool,
-}
-
-impl Default for LocalFixedTimestepState {
-    fn default() -> Self {
-        Self {
-            step: 1.0 / 60.0,
-            accumulator: 0.0,
-            label: None,
-            looping: false,
-        }
-    }
-}
-
-impl LocalFixedTimestepState {
-    fn update(&mut self, time: &Time) -> ShouldRun {
-        if !self.looping {
-            self.accumulator += time.delta_seconds_f64();
-        }
-
-        if self.accumulator >= self.step {
-            self.accumulator -= self.step;
-            self.looping = true;
-            ShouldRun::YesAndCheckAgain
-        } else {
-            self.looping = false;
-            ShouldRun::No
-        }
-    }
-}
-
-impl System for FixedTimestep {
-    type In = ();
-    type Out = ShouldRun;
-
-    fn name(&self) -> Cow<'static, str> {
-        Cow::Borrowed(std::any::type_name::<FixedTimestep>())
-    }
-
-    fn archetype_component_access(&self) -> &Access<ArchetypeComponentId> {
-        self.internal_system.archetype_component_access()
-    }
-
-    fn component_access(&self) -> &Access<ComponentId> {
-        self.internal_system.component_access()
-    }
-
-    fn is_send(&self) -> bool {
-        self.internal_system.is_send()
-    }
-
-    unsafe fn run_unsafe(&mut self, _input: (), world: &World) -> ShouldRun {
-        // SAFETY: this system inherits the internal system's component access and archetype component
-        // access, which means the caller has ensured running the internal system is safe
-        self.internal_system.run_unsafe((), world)
-    }
-
-    fn apply_buffers(&mut self, world: &mut World) {
-        self.internal_system.apply_buffers(world);
-    }
-
-    fn initialize(&mut self, world: &mut World) {
-        self.internal_system = Box::new(IntoSystem::into_system(Self::prepare_system(
-            self.state.clone(),
-        )));
-        self.internal_system.initialize(world);
-        if let Some(ref label) = self.state.label {
-            let mut fixed_timesteps = world.resource_mut::<FixedTimesteps>();
-            fixed_timesteps.fixed_timesteps.insert(
-                label.clone(),
-                FixedTimestepState {
-                    accumulator: 0.0,
-                    step: self.state.step,
-                },
-            );
-        }
-    }
-
-    fn update_archetype_component_access(&mut self, world: &World) {
-        self.internal_system
-            .update_archetype_component_access(world);
-    }
-
-    fn check_change_tick(&mut self, change_tick: u32) {
-        self.internal_system.check_change_tick(change_tick);
-    }
 }
 
 #[cfg(test)]
@@ -235,65 +209,64 @@ mod test {
     use std::time::Duration;
 
     type Count = usize;
-    const LABEL: &str = "test_step";
+
+    #[derive(ScheduleLabel)]
+    struct FixedUpdate;
 
     #[test]
     fn test() {
-        let mut world = World::default();
+        let mut app = App::new();
         let mut time = Time::default();
         let instance = Instant::now();
         time.update_with_instant(instance);
-        world.insert_resource(time);
-        world.insert_resource(FixedTimesteps::default());
-        world.insert_resource::<Count>(0);
-        let mut schedule = Schedule::default();
-
-        schedule.add_stage(
-            "update",
-            SystemStage::parallel()
-                .with_run_criteria(FixedTimestep::step(0.5).with_label(LABEL))
-                .with_system(fixed_update),
+        app.insert_resource(time);
+        app.insert_resource::<Count>(0);
+
+        // Add a new fixed timestep that runs every 0.5 seconds.
+        app.add_fixed_schedule(
+            FixedTimestep::step(0.5).with_label(FixedUpdate),
+            SystemStage::single_threaded().with_system(fixed_update),
         );
 
         // if time does not progress, the step does not run
-        schedule.run(&mut world);
-        schedule.run(&mut world);
-        assert_eq!(0, *world.resource::<Count>());
-        assert_eq!(0., get_accumulator_deciseconds(&world));
+        app.update();
+        app.update();
+        assert_eq!(0, *app.world.resource::<Count>());
+        assert_eq!(0., get_accumulator_deciseconds(&app.world));
 
         // let's progress less than one step
-        advance_time(&mut world, instance, 0.4);
-        schedule.run(&mut world);
-        assert_eq!(0, *world.resource::<Count>());
-        assert_eq!(4., get_accumulator_deciseconds(&world));
+        advance_time(&mut app.world, instance, 0.4);
+        app.update();
+        assert_eq!(0, *app.world.resource::<Count>());
+        assert_eq!(4., get_accumulator_deciseconds(&app.world));
 
         // finish the first step with 0.1s above the step length
-        advance_time(&mut world, instance, 0.6);
-        schedule.run(&mut world);
-        assert_eq!(1, *world.resource::<Count>());
-        assert_eq!(1., get_accumulator_deciseconds(&world));
+        advance_time(&mut app.world, instance, 0.6);
+        app.update();
+        assert_eq!(1, *app.world.resource::<Count>());
+        assert_eq!(1., get_accumulator_deciseconds(&app.world));
 
         // runs multiple times if the delta is multiple step lengths
-        advance_time(&mut world, instance, 1.7);
-        schedule.run(&mut world);
-        assert_eq!(3, *world.resource::<Count>());
-        assert_eq!(2., get_accumulator_deciseconds(&world));
+        advance_time(&mut app.world, instance, 1.7);
+        app.update();
+        assert_eq!(3, *app.world.resource::<Count>());
+        assert_eq!(2., get_accumulator_deciseconds(&app.world));
     }
 
     fn fixed_update(mut count: ResMut<Count>) {
         *count += 1;
     }
 
-    fn advance_time(world: &mut World, instance: Instant, seconds: f32) {
+    fn advance_time(world: &mut World, instance: Instant, seconds: f64) {
         world
             .resource_mut::<Time>()
-            .update_with_instant(instance.add(Duration::from_secs_f32(seconds)));
+            .update_with_instant(instance.add(Duration::from_secs_f64(seconds)));
     }
 
     fn get_accumulator_deciseconds(world: &World) -> f64 {
         world
             .resource::<FixedTimesteps>()
-            .get(LABEL)
+            .get(FixedUpdate)
             .unwrap()
             .accumulator
             .mul(10.)
diff --git a/crates/bevy_time/src/lib.rs b/crates/bevy_time/src/lib.rs
index 5982305159766..69c9abfbeb140 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -16,7 +16,7 @@ use crossbeam_channel::{Receiver, Sender};
 pub mod prelude {
     //! The Bevy Time Prelude.
     #[doc(hidden)]
-    pub use crate::{Time, Timer};
+    pub use crate::{Time, Timer, TimestepAppExt};
 }
 
 use bevy_app::prelude::*;
@@ -34,7 +34,6 @@ pub struct TimeSystem;
 impl Plugin for TimePlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<Time>()
-            .init_resource::<FixedTimesteps>()
             .register_type::<Timer>()
             // time system is added as an "exclusive system" to ensure it runs before other systems
             // in CoreStage::First

From d7f3852cb55e794cdb1a46527d43f4da16cb0ee4 Mon Sep 17 00:00:00 2001
From: JoJoJet <joe102000@gmail.com>
Date: Tue, 26 Jul 2022 23:25:05 -0400
Subject: [PATCH 03/10] update examples

---
 examples/2d/rotation.rs             |  6 +++---
 examples/ecs/fixed_timestep.rs      | 30 +++++++++--------------------
 examples/ecs/iter_combinations.rs   |  6 ++----
 examples/games/alien_cake_addict.rs |  7 +++----
 examples/games/breakout.rs          |  6 +++---
 examples/stress_tests/bevymark.rs   |  8 ++++----
 6 files changed, 24 insertions(+), 39 deletions(-)

diff --git a/examples/2d/rotation.rs b/examples/2d/rotation.rs
index 7c6a5e91d5aaf..8048e5fab04d3 100644
--- a/examples/2d/rotation.rs
+++ b/examples/2d/rotation.rs
@@ -9,9 +9,9 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup)
-        .add_system_set(
-            SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(TIME_STEP as f64))
+        .add_fixed_schedule(
+            FixedTimestep::step(TIME_STEP as f64),
+            SystemStage::parallel()
                 .with_system(player_movement_system)
                 .with_system(snap_to_player_system)
                 .with_system(rotate_to_player_system),
diff --git a/examples/ecs/fixed_timestep.rs b/examples/ecs/fixed_timestep.rs
index 0f58e7d531ee8..4b6b43516256e 100644
--- a/examples/ecs/fixed_timestep.rs
+++ b/examples/ecs/fixed_timestep.rs
@@ -5,28 +5,19 @@ use bevy::{
     time::{FixedTimestep, FixedTimesteps},
 };
 
-const LABEL: &str = "my_fixed_timestep";
-
-#[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
-struct FixedUpdateStage;
+/// Label for our fixed time-step.
+#[derive(ScheduleLabel)]
+struct FixedUpdate;
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         // this system will run once every update (it should match your screen's refresh rate)
         .add_system(frame_update)
-        // add a new stage that runs twice a second
-        .add_stage_after(
-            CoreStage::Update,
-            FixedUpdateStage,
-            SystemStage::parallel()
-                .with_run_criteria(
-                    FixedTimestep::step(0.5)
-                        // labels are optional. they provide a way to access the current
-                        // FixedTimestep state from within a system
-                        .with_label(LABEL),
-                )
-                .with_system(fixed_update),
+        // add a new schedule that runs twice a second
+        .add_fixed_schedule(
+            FixedTimestep::step(0.5).with_label(FixedUpdate),
+            SystemStage::single_threaded().with_system(fixed_update),
         )
         .run();
 }
@@ -42,11 +33,8 @@ fn fixed_update(mut last_time: Local<f64>, time: Res<Time>, fixed_timesteps: Res
         time.seconds_since_startup() - *last_time,
     );
 
-    let fixed_timestep = fixed_timesteps.get(LABEL).unwrap();
-    info!(
-        "  overstep_percentage: {}",
-        fixed_timestep.overstep_percentage()
-    );
+    let dbg = fixed_timesteps.get(FixedUpdate).unwrap();
+    info!("  overstep_percentage: {}", dbg.overstep_percentage());
 
     *last_time = time.seconds_since_startup();
 }
diff --git a/examples/ecs/iter_combinations.rs b/examples/ecs/iter_combinations.rs
index b66f9148b33a1..31d2683d66a41 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -16,11 +16,9 @@ fn main() {
             ..default()
         })
         .add_startup_system(generate_bodies)
-        .add_stage_after(
-            CoreStage::Update,
-            FixedUpdateStage,
+        .add_fixed_schedule(
+            FixedTimestep::step(DELTA_TIME),
             SystemStage::parallel()
-                .with_run_criteria(FixedTimestep::step(DELTA_TIME))
                 .with_system(interact_bodies)
                 .with_system(integrate),
         )
diff --git a/examples/games/alien_cake_addict.rs b/examples/games/alien_cake_addict.rs
index f0a6b4e0c05cf..6a2ed15aae624 100644
--- a/examples/games/alien_cake_addict.rs
+++ b/examples/games/alien_cake_addict.rs
@@ -27,10 +27,9 @@ fn main() {
         .add_system_set(SystemSet::on_enter(GameState::GameOver).with_system(display_score))
         .add_system_set(SystemSet::on_update(GameState::GameOver).with_system(gameover_keyboard))
         .add_system_set(SystemSet::on_exit(GameState::GameOver).with_system(teardown))
-        .add_system_set(
-            SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(5.0))
-                .with_system(spawn_bonus),
+        .add_fixed_schedule(
+            FixedTimestep::step(5.0),
+            SystemStage::single_threaded().with_system(spawn_bonus),
         )
         .add_system(bevy::window::close_on_esc)
         .run();
diff --git a/examples/games/breakout.rs b/examples/games/breakout.rs
index 2260ed91a58c8..30ca2a652be0e 100644
--- a/examples/games/breakout.rs
+++ b/examples/games/breakout.rs
@@ -57,9 +57,9 @@ fn main() {
         .insert_resource(ClearColor(BACKGROUND_COLOR))
         .add_startup_system(setup)
         .add_event::<CollisionEvent>()
-        .add_system_set(
-            SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(TIME_STEP as f64))
+        .add_fixed_schedule(
+            FixedTimestep::step(TIME_STEP as f64),
+            SystemStage::parallel()
                 .with_system(check_for_collisions)
                 .with_system(move_paddle.before(check_for_collisions))
                 .with_system(apply_velocity.before(check_for_collisions))
diff --git a/examples/stress_tests/bevymark.rs b/examples/stress_tests/bevymark.rs
index 249e506ce0f15..d8a2fa24ae374 100644
--- a/examples/stress_tests/bevymark.rs
+++ b/examples/stress_tests/bevymark.rs
@@ -48,10 +48,10 @@ fn main() {
         .add_system(movement_system)
         .add_system(collision_system)
         .add_system(counter_system)
-        .add_system_set(
-            SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(0.2))
-                .with_system(scheduled_spawner),
+        // System that runs every 0.2 seconds
+        .add_fixed_schedule(
+            FixedTimestep::step(0.2),
+            SystemStage::single_threaded().with_system(scheduled_spawner),
         )
         .run();
 }

From cb54639f39ae4dba64926fbc508602386e252355 Mon Sep 17 00:00:00 2001
From: JoJoJet <joe102000@gmail.com>
Date: Thu, 28 Jul 2022 20:19:35 -0400
Subject: [PATCH 04/10] use fallible APIs

---
 crates/bevy_app/Cargo.toml          |   1 +
 crates/bevy_app/src/sub_schedule.rs | 103 +++++++++++++++++++---------
 2 files changed, 72 insertions(+), 32 deletions(-)

diff --git a/crates/bevy_app/Cargo.toml b/crates/bevy_app/Cargo.toml
index a60532fbb0a56..053f3c558c694 100644
--- a/crates/bevy_app/Cargo.toml
+++ b/crates/bevy_app/Cargo.toml
@@ -25,6 +25,7 @@ bevy_tasks = { path = "../bevy_tasks", version = "0.8.0-dev" }
 # other
 serde = { version = "1.0", features = ["derive"], optional = true }
 ron = { version = "0.7.0", optional = true }
+thiserror = "1.0"
 
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
diff --git a/crates/bevy_app/src/sub_schedule.rs b/crates/bevy_app/src/sub_schedule.rs
index c29f9e73ed5a0..8e5d45dce1f48 100644
--- a/crates/bevy_app/src/sub_schedule.rs
+++ b/crates/bevy_app/src/sub_schedule.rs
@@ -1,4 +1,4 @@
-use std::fmt::Debug;
+use std::fmt::{Debug, Display};
 
 use bevy_ecs::{
     change_detection::Mut,
@@ -7,6 +7,7 @@ use bevy_ecs::{
     world::World,
 };
 use bevy_utils::HashMap;
+use thiserror::Error;
 
 use crate::App;
 
@@ -92,61 +93,99 @@ pub struct SubSchedules {
 }
 
 struct SubSlot(Option<Box<dyn Stage>>);
+
+/// Error type returned by [`SubSchedules::extract_from`](SubSchedules#method.extract_from).
+#[derive(Error)]
+#[non_exhaustive]
+pub enum ExtractError {
+    /// Schedule could not be found.
+    #[error("there is no sub-schedule with label '{0:?}'")]
+    NotFound(ScheduleLabelId),
+    /// Schedule is being extracted by someone else right now.
+    #[error("cannot extract sub-schedule '{0:?}', as it is currently extracted already")]
+    AlreadyExtracted(ScheduleLabelId),
+    /// The [`SubSchedules`] resource got removed during the scope.
+    #[error("the `SubSchedules` resource got removed during the scope for schedule '{0:?}'")]
+    ResourceLost(ScheduleLabelId),
+}
+impl Debug for ExtractError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(self, f)
+    }
+}
+
+#[derive(Error)]
+/// Error type returned by [`SubSchedules::insert`](SubSchedules#method.insert).
+#[non_exhaustive]
+pub enum InsertError {
+    /// A schedule with this label already exists.
+    #[error("there is no sub-schedule with label '{0:?}'")]
+    Duplicate(ScheduleLabelId),
+}
+impl Debug for InsertError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(self, f)
+    }
+}
+
 impl SubSchedules {
     /// Inserts a new sub-schedule.
     ///
-    /// # Panics
+    /// # Errors
     /// If there is already a sub-schedule labeled `label`.
-    #[track_caller]
-    pub fn insert(&mut self, label: impl ScheduleLabel, sched: Box<dyn Stage>) {
+    pub fn insert(
+        &mut self,
+        label: impl ScheduleLabel,
+        sched: Box<dyn Stage>,
+    ) -> Result<(), InsertError> {
         let label = label.as_label();
-        let old = self.map.insert(label, SubSlot(Some(sched)));
-        if old.is_some() {
-            panic!("there is already a sub-schedule with label '{label:?}'");
+        if self.map.contains_key(&label) {
+            return Err(InsertError::Duplicate(label));
         }
+        self.map.insert(label, SubSlot(Some(sched)));
+        Ok(())
     }
 
     /// Temporarily extracts a [`SubSchedule`] from the world, and provides a scope
     /// that has mutable access to both the schedule and the [`World`].
     /// At the end of this scope, the sub-schedule is automatically reinserted.
     ///
-    /// # Panics
+    /// # Errors
     /// If there is no schedule associated with `label`, or if that schedule
     /// is currently already extracted.
-    #[track_caller]
-    pub fn extract_scope<F, T>(world: &mut World, label: impl ScheduleLabel, f: F) -> T
+    pub fn extract_scope<F, T>(
+        world: &mut World,
+        label: impl ScheduleLabel,
+        f: F,
+    ) -> Result<T, ExtractError>
     where
         F: FnOnce(&mut World, &mut dyn Stage) -> T,
     {
-        #[inline(never)]
-        fn panic_none(label: impl Debug) -> ! {
-            panic!("there is no sub-schedule with label '{label:?}'")
-        }
-        #[inline(never)]
-        fn panic_extracted(label: impl Debug) -> ! {
-            panic!("cannot extract sub-schedule '{label:?}', as it is currently extracted already")
-        }
-
         let label = label.as_label();
 
         // Extract.
         let mut schedules = world.resource_mut::<Self>();
-        let mut sched = match schedules.map.get_mut(&label) {
-            Some(x) => match x.0.take() {
-                Some(x) => x,
-                None => panic_extracted(label),
-            },
-            None => panic_none(label),
-        };
+        let mut sched = schedules
+            .map
+            .get_mut(&label)
+            .ok_or(ExtractError::NotFound(label))?
+            .0
+            .take()
+            .ok_or(ExtractError::AlreadyExtracted(label))?;
 
         // Execute.
         let val = f(world, sched.as_mut());
 
         // Re-insert.
-        let mut schedules = world.resource_mut::<Self>();
-        schedules.map.get_mut(&label).unwrap().0 = Some(sched);
-
-        val
+        world
+            .get_resource_mut::<Self>()
+            .ok_or(ExtractError::ResourceLost(label))?
+            .map
+            .get_mut(&label)
+            .expect("schedule must exist in the map since we found it previously")
+            .0 = Some(sched);
+
+        Ok(val)
     }
 
     /// Gets a mutable reference to the sub-schedule identified by `label`.
@@ -179,7 +218,7 @@ pub(crate) fn add_to_app<S: Stage>(app: &mut App, schedule: impl IntoSubSchedule
     // If it has a label, insert it to the public resource.
     if let Some(label) = label {
         let mut res: Mut<SubSchedules> = app.world.get_resource_or_insert_with(Default::default);
-        res.insert(label, Box::new(schedule));
+        res.insert(label, Box::new(schedule)).unwrap();
 
         if let Some((stage, mut runner)) = runner {
             // Driver which extracts the schedule from the world and runs it.
@@ -199,7 +238,7 @@ pub(crate) fn add_to_app<S: Stage>(app: &mut App, schedule: impl IntoSubSchedule
                         }
                     };
                     runner(sched, w);
-                });
+                }).unwrap();
             };
             app.add_system_to_stage(stage, driver.exclusive_system());
         }

From b611dfd30be89afed28aeb63aee92c808447484a Mon Sep 17 00:00:00 2001
From: JoJoJet <joe102000@gmail.com>
Date: Fri, 29 Jul 2022 09:33:56 -0400
Subject: [PATCH 05/10] improve a panic message

---
 crates/bevy_app/src/sub_schedule.rs | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_app/src/sub_schedule.rs b/crates/bevy_app/src/sub_schedule.rs
index 8e5d45dce1f48..a09590f70874d 100644
--- a/crates/bevy_app/src/sub_schedule.rs
+++ b/crates/bevy_app/src/sub_schedule.rs
@@ -228,7 +228,15 @@ pub(crate) fn add_to_app<S: Stage>(app: &mut App, schedule: impl IntoSubSchedule
                         s
                     } else {
                         #[cfg(debug_assertions)]
-                        unreachable!("the sub-schedule '{label:?}' somehow changed type after being inserted!");
+                        unreachable!(
+                            r#"
+                            The sub-schedule '{label:?}' changed types after being inserted:
+                            it should be of type `{expect}`, but it's really of type `{actual}`.
+                            This should be impossible.
+                            If run into this error, please file an issue at https://github.com/bevyengine/bevy/issues/new/choose"#,
+                            expect = std::any::type_name::<S>(),
+                            actual = AnyTypeName::name(sched),
+                        );
                         // SAFETY: Due to the invariant on `SubSchedules`, we can be sure that
                         // `sched` is the same instance that we inserted.
                         // Thus, we can rely on its type matching `S`.
@@ -238,7 +246,8 @@ pub(crate) fn add_to_app<S: Stage>(app: &mut App, schedule: impl IntoSubSchedule
                         }
                     };
                     runner(sched, w);
-                }).unwrap();
+                })
+                .unwrap();
             };
             app.add_system_to_stage(stage, driver.exclusive_system());
         }
@@ -253,3 +262,13 @@ pub(crate) fn add_to_app<S: Stage>(app: &mut App, schedule: impl IntoSubSchedule
         panic!("inserted sub-schedule can never be accessed, as it has neither a label nor a runner function")
     }
 }
+
+/// Trait that lets us get the type name of a trait object for debugging purposes.
+trait AnyTypeName: 'static {
+    fn name(&self) -> &'static str;
+}
+impl<T: ?Sized + 'static> AnyTypeName for T {
+    fn name(&self) -> &'static str {
+        std::any::type_name::<Self>()
+    }
+}

From aa54393cfa54e458684ddec37bfe4c7da6003bf7 Mon Sep 17 00:00:00 2001
From: JoJoJet <joe102000@gmail.com>
Date: Fri, 29 Jul 2022 10:50:30 -0400
Subject: [PATCH 06/10] fix a soundness issue

---
 crates/bevy_app/src/sub_schedule.rs | 59 +++++++++--------------------
 1 file changed, 17 insertions(+), 42 deletions(-)

diff --git a/crates/bevy_app/src/sub_schedule.rs b/crates/bevy_app/src/sub_schedule.rs
index a09590f70874d..a08b040b2d48e 100644
--- a/crates/bevy_app/src/sub_schedule.rs
+++ b/crates/bevy_app/src/sub_schedule.rs
@@ -13,16 +13,14 @@ use crate::App;
 
 /// Methods for converting a schedule into a [sub-Schedule](SubSchedule) descriptor.
 pub trait IntoSubSchedule: Sized {
-    /// The wrapped schedule type.
-    type Sched: Stage;
     /// The type that controls the behaviour of the exclusive system
     /// which runs [`SubSchedule`]s of this type.
-    type Runner: FnMut(&mut Self::Sched, &mut World) + Send + Sync + 'static;
+    type Runner: FnMut(&mut dyn Stage, &mut World) + Send + Sync + 'static;
 
     /// Applies the specified label to the current schedule.
     /// This means it will be accessible in the [`SubSchedules`] resource after
     /// being added to the [`App`].
-    fn label(self, label: impl ScheduleLabel) -> SubSchedule<Self::Sched, Self::Runner> {
+    fn label(self, label: impl ScheduleLabel) -> SubSchedule<Self::Runner> {
         let mut sub = Self::into_sched(self);
         sub.label = Some(label.as_label());
         sub
@@ -31,9 +29,9 @@ pub trait IntoSubSchedule: Sized {
     /// an exclusive system within the stage `stage`.
     ///
     /// Overwrites any previously set runner or stage.
-    fn with_runner<F>(self, stage: impl StageLabel, f: F) -> SubSchedule<Self::Sched, F>
+    fn with_runner<F>(self, stage: impl StageLabel, f: F) -> SubSchedule<F>
     where
-        F: FnMut(&mut Self::Sched, &mut World) + Send + Sync + 'static,
+        F: FnMut(&mut dyn Stage, &mut World) + Send + Sync + 'static,
     {
         let SubSchedule {
             schedule, label, ..
@@ -46,39 +44,37 @@ pub trait IntoSubSchedule: Sized {
     }
 
     /// Performs the conversion. You usually do not need to call this directly.
-    fn into_sched(_: Self) -> SubSchedule<Self::Sched, Self::Runner>;
+    fn into_sched(_: Self) -> SubSchedule<Self::Runner>;
 }
 
 impl<S: Stage> IntoSubSchedule for S {
-    type Sched = Self;
-    type Runner = fn(&mut Self, &mut World);
-    fn into_sched(schedule: Self) -> SubSchedule<Self, Self::Runner> {
+    type Runner = fn(&mut dyn Stage, &mut World);
+    fn into_sched(schedule: Self) -> SubSchedule<Self::Runner> {
         SubSchedule {
-            schedule,
+            schedule: Box::new(schedule),
             label: None,
             runner: None,
         }
     }
 }
 
-impl<S: Stage, R> IntoSubSchedule for SubSchedule<S, R>
+impl<R> IntoSubSchedule for SubSchedule<R>
 where
-    R: FnMut(&mut S, &mut World) + Send + Sync + 'static,
+    R: FnMut(&mut dyn Stage, &mut World) + Send + Sync + 'static,
 {
-    type Sched = S;
     type Runner = R;
     #[inline]
-    fn into_sched(sched: Self) -> SubSchedule<S, R> {
+    fn into_sched(sched: Self) -> SubSchedule<R> {
         sched
     }
 }
 
 /// A schedule that may run independently of the main app schedule.
-pub struct SubSchedule<S: Stage, F>
+pub struct SubSchedule<F>
 where
-    F: FnMut(&mut S, &mut World) + Send + Sync + 'static,
+    F: FnMut(&mut dyn Stage, &mut World) + Send + Sync + 'static,
 {
-    schedule: S,
+    schedule: Box<dyn Stage>,
     label: Option<ScheduleLabelId>,
     runner: Option<(StageLabelId, F)>,
 }
@@ -208,7 +204,7 @@ impl SubSchedules {
 }
 
 #[track_caller]
-pub(crate) fn add_to_app<S: Stage>(app: &mut App, schedule: impl IntoSubSchedule<Sched = S>) {
+pub(crate) fn add_to_app(app: &mut App, schedule: impl IntoSubSchedule) {
     let SubSchedule {
         mut schedule,
         label,
@@ -218,33 +214,12 @@ pub(crate) fn add_to_app<S: Stage>(app: &mut App, schedule: impl IntoSubSchedule
     // If it has a label, insert it to the public resource.
     if let Some(label) = label {
         let mut res: Mut<SubSchedules> = app.world.get_resource_or_insert_with(Default::default);
-        res.insert(label, Box::new(schedule)).unwrap();
+        res.insert(label, schedule).unwrap();
 
         if let Some((stage, mut runner)) = runner {
             // Driver which extracts the schedule from the world and runs it.
             let driver = move |w: &mut World| {
                 SubSchedules::extract_scope(w, label, |w, sched| {
-                    let sched = if let Some(s) = sched.downcast_mut::<S>() {
-                        s
-                    } else {
-                        #[cfg(debug_assertions)]
-                        unreachable!(
-                            r#"
-                            The sub-schedule '{label:?}' changed types after being inserted:
-                            it should be of type `{expect}`, but it's really of type `{actual}`.
-                            This should be impossible.
-                            If run into this error, please file an issue at https://github.com/bevyengine/bevy/issues/new/choose"#,
-                            expect = std::any::type_name::<S>(),
-                            actual = AnyTypeName::name(sched),
-                        );
-                        // SAFETY: Due to the invariant on `SubSchedules`, we can be sure that
-                        // `sched` is the same instance that we inserted.
-                        // Thus, we can rely on its type matching `S`.
-                        #[cfg(not(debug_assertions))]
-                        unsafe {
-                            std::hint::unreachable_unchecked()
-                        }
-                    };
                     runner(sched, w);
                 })
                 .unwrap();
@@ -255,7 +230,7 @@ pub(crate) fn add_to_app<S: Stage>(app: &mut App, schedule: impl IntoSubSchedule
         // If there's no label, then the schedule isn't visible publicly.
         // We can just store it locally
         let driver = move |w: &mut World| {
-            runner(&mut schedule, w);
+            runner(schedule.as_mut(), w);
         };
         app.add_system_to_stage(stage, driver.exclusive_system());
     } else {

From b07208b2438a55e711d4e7c1708585f2978c66d3 Mon Sep 17 00:00:00 2001
From: JoJoJet <joe102000@gmail.com>
Date: Fri, 29 Jul 2022 11:34:31 -0400
Subject: [PATCH 07/10] update fixed timestep

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

diff --git a/crates/bevy_time/src/fixed_timestep.rs b/crates/bevy_time/src/fixed_timestep.rs
index 5dfede95e8e63..ce2a8dc2f9ed4 100644
--- a/crates/bevy_time/src/fixed_timestep.rs
+++ b/crates/bevy_time/src/fixed_timestep.rs
@@ -61,7 +61,7 @@ impl TimestepAppExt for App {
                 panic(label)
             }
 
-            let runner = move |s: &mut S, w: &mut World| {
+            let runner = move |s: &mut dyn Stage, w: &mut World| {
                 let mut state = *w.resource::<FixedTimesteps>().get(label).unwrap();
 
                 // Core looping functionality.
@@ -85,7 +85,7 @@ impl TimestepAppExt for App {
                 step,
                 accumulator: 0.0,
             };
-            let runner = move |sched: &mut S, w: &mut World| {
+            let runner = move |sched: &mut dyn Stage, w: &mut World| {
                 // Core looping functionality.
                 let time = w.resource::<Time>();
                 state.accumulator += time.delta_seconds_f64();

From 444c8f08dab6fcf74f0200ef10c08f21de7d8ac2 Mon Sep 17 00:00:00 2001
From: JoJoJet <joe102000@gmail.com>
Date: Sat, 30 Jul 2022 01:25:35 -0400
Subject: [PATCH 08/10] fix an error message

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

diff --git a/crates/bevy_app/src/sub_schedule.rs b/crates/bevy_app/src/sub_schedule.rs
index a08b040b2d48e..227a0ae37fb6e 100644
--- a/crates/bevy_app/src/sub_schedule.rs
+++ b/crates/bevy_app/src/sub_schedule.rs
@@ -115,7 +115,7 @@ impl Debug for ExtractError {
 #[non_exhaustive]
 pub enum InsertError {
     /// A schedule with this label already exists.
-    #[error("there is no sub-schedule with label '{0:?}'")]
+    #[error("a sub-schedule with label '{0:?}' already exists")]
     Duplicate(ScheduleLabelId),
 }
 impl Debug for InsertError {

From 89aad3f9b56f9fc49b0fb206f3edf57241711c2c Mon Sep 17 00:00:00 2001
From: JoJoJet <joe102000@gmail.com>
Date: Sat, 30 Jul 2022 01:38:56 -0400
Subject: [PATCH 09/10] remove an unused trait

---
 crates/bevy_app/src/sub_schedule.rs | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/crates/bevy_app/src/sub_schedule.rs b/crates/bevy_app/src/sub_schedule.rs
index 227a0ae37fb6e..a2b0eb303e378 100644
--- a/crates/bevy_app/src/sub_schedule.rs
+++ b/crates/bevy_app/src/sub_schedule.rs
@@ -237,13 +237,3 @@ pub(crate) fn add_to_app(app: &mut App, schedule: impl IntoSubSchedule) {
         panic!("inserted sub-schedule can never be accessed, as it has neither a label nor a runner function")
     }
 }
-
-/// Trait that lets us get the type name of a trait object for debugging purposes.
-trait AnyTypeName: 'static {
-    fn name(&self) -> &'static str;
-}
-impl<T: ?Sized + 'static> AnyTypeName for T {
-    fn name(&self) -> &'static str {
-        std::any::type_name::<Self>()
-    }
-}

From 7f6118bcd7f9520bf29f78416133a4969b407ad8 Mon Sep 17 00:00:00 2001
From: JoJoJet <joe102000@gmail.com>
Date: Mon, 8 Aug 2022 10:45:21 -0400
Subject: [PATCH 10/10] use `Duration` for fixed timestep

---
 crates/bevy_time/src/fixed_timestep.rs | 30 +++++++++++++++-----------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_time/src/fixed_timestep.rs b/crates/bevy_time/src/fixed_timestep.rs
index ce2a8dc2f9ed4..fcbfdfcad8051 100644
--- a/crates/bevy_time/src/fixed_timestep.rs
+++ b/crates/bevy_time/src/fixed_timestep.rs
@@ -6,7 +6,7 @@ use bevy_ecs::{
     schedule::{ScheduleLabel, ScheduleLabelId, Stage, StageLabel},
     world::World,
 };
-use bevy_utils::HashMap;
+use bevy_utils::{Duration, HashMap};
 
 use crate::Time;
 
@@ -47,7 +47,7 @@ impl TimestepAppExt for App {
                 self.world.get_resource_or_insert_with(Default::default);
             let state = FixedTimestepState {
                 step,
-                accumulator: 0.0,
+                accumulator: Duration::ZERO,
             };
 
             // Insert the state into the map.
@@ -66,7 +66,7 @@ impl TimestepAppExt for App {
 
                 // Core looping functionality.
                 let time = w.resource::<Time>();
-                state.accumulator += time.delta_seconds_f64();
+                state.accumulator += time.delta();
                 while state.accumulator > state.step {
                     state.accumulator -= state.step;
 
@@ -83,12 +83,12 @@ impl TimestepAppExt for App {
         else {
             let mut state = FixedTimestepState {
                 step,
-                accumulator: 0.0,
+                accumulator: Duration::ZERO,
             };
             let runner = move |sched: &mut dyn Stage, w: &mut World| {
                 // Core looping functionality.
                 let time = w.resource::<Time>();
-                state.accumulator += time.delta_seconds_f64();
+                state.accumulator += time.delta();
                 while state.accumulator > state.step {
                     state.accumulator -= state.step;
 
@@ -105,29 +105,29 @@ impl TimestepAppExt for App {
 /// The internal state of each [`FixedTimestep`].
 #[derive(Debug, Clone, Copy)]
 pub struct FixedTimestepState {
-    step: f64,
-    accumulator: f64,
+    step: Duration,
+    accumulator: Duration,
 }
 
 impl FixedTimestepState {
     /// The amount of time each step takes.
     pub fn step(&self) -> f64 {
-        self.step
+        self.step.as_secs_f64()
     }
 
     /// The number of steps made in a second.
     pub fn steps_per_second(&self) -> f64 {
-        1.0 / self.step
+        self.step.as_secs_f64().recip()
     }
 
     /// The amount of time (in seconds) left over from the last step.
     pub fn accumulator(&self) -> f64 {
-        self.accumulator
+        self.accumulator.as_secs_f64()
     }
 
     /// The percentage of "step" stored inside the accumulator. Calculated as accumulator / step.
     pub fn overstep_percentage(&self) -> f64 {
-        self.accumulator / self.step
+        self.accumulator.as_secs_f64() / self.step.as_secs_f64()
     }
 }
 
@@ -171,7 +171,7 @@ impl FixedTimesteps {
 /// use the [`FixedTimesteps`] resource.
 pub struct FixedTimestep {
     label: Option<ScheduleLabelId>,
-    step: f64,
+    step: Duration,
 }
 
 impl Default for FixedTimestep {
@@ -183,7 +183,10 @@ impl Default for FixedTimestep {
 impl FixedTimestep {
     /// Creates a [`FixedTimestep`] that ticks once every `step` seconds.
     pub fn step(step: f64) -> Self {
-        Self { step, label: None }
+        Self {
+            step: Duration::from_secs_f64(step),
+            label: None,
+        }
     }
 
     /// Creates a [`FixedTimestep`] that ticks once every `rate` times per second.
@@ -269,6 +272,7 @@ mod test {
             .get(FixedUpdate)
             .unwrap()
             .accumulator
+            .as_secs_f64()
             .mul(10.)
             .round()
     }