Add bevy_ecs::schedule_v3 module

Author: maniwani

crates/bevy_ecs/Cargo.toml

@@ -28,6 +28,8 @@ fxhash = "0.2"
 downcast-rs = "1.2"
 serde = { version = "1", features = ["derive"] }
 
+petgraph = "0.6"
+
 [dev-dependencies]
 rand = "0.8"
 

crates/bevy_ecs/macros/src/lib.rs

@@ -4,7 +4,9 @@ mod component;
 mod fetch;
 
 use crate::fetch::derive_world_query_impl;
-use bevy_macro_utils::{derive_label, get_named_struct_fields, BevyManifest};
+use bevy_macro_utils::{
+    derive_label, derive_old_style_label, derive_set, get_named_struct_fields, BevyManifest,
+};
 use proc_macro::TokenStream;
 use proc_macro2::Span;
 use quote::{format_ident, quote};
@@ -502,6 +504,32 @@ pub fn derive_run_criteria_label(input: TokenStream) -> TokenStream {
     derive_label(input, &trait_path, "run_criteria_label")
 }
 
+/// Derive macro generating an impl of the trait `ScheduleLabel`.
+#[proc_macro_derive(ScheduleLabel)]
+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_v3").into());
+    trait_path
+        .segments
+        .push(format_ident!("ScheduleLabel").into());
+    derive_old_style_label(input, &trait_path)
+}
+
+/// Derive macro generating an impl of the trait `SystemSet`.
+#[proc_macro_derive(SystemSet)]
+pub fn derive_system_set(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_v3").into());
+    trait_path.segments.push(format_ident!("SystemSet").into());
+    derive_set(input, &trait_path)
+}
+
 pub(crate) fn bevy_ecs_path() -> syn::Path {
     BevyManifest::default().get_path("bevy_ecs")
 }

crates/bevy_ecs/src/lib.rs

@@ -14,6 +14,7 @@ pub mod query;
 #[cfg(feature = "bevy_reflect")]
 pub mod reflect;
 pub mod schedule;
+pub mod schedule_v3;
 pub mod storage;
 pub mod system;
 pub mod world;

crates/bevy_ecs/src/schedule_v3/condition.rs

@@ -0,0 +1,94 @@
+pub use helper::*;
+
+use crate::system::BoxedSystem;
+
+pub type BoxedCondition = BoxedSystem<(), bool>;
+
+/// Functions and closures that convert into [`System<In=(), Out=bool>`](crate::system::System)
+/// trait objects and have [read-only](crate::system::ReadOnlySystemParamFetch) parameters.
+pub trait Condition<Params>: sealed::Condition<Params> {}
+
+impl<Params, F> Condition<Params> for F where F: sealed::Condition<Params> {}
+
+mod sealed {
+    use crate::system::{
+        IntoSystem, IsFunctionSystem, ReadOnlySystemParamFetch, SystemParam, SystemParamFunction,
+    };
+
+    pub trait Condition<Params>: IntoSystem<(), bool, Params> {}
+
+    impl<Params, Marker, F> Condition<(IsFunctionSystem, Params, Marker)> for F
+    where
+        F: SystemParamFunction<(), bool, Params, Marker> + Send + Sync + 'static,
+        Params: SystemParam + 'static,
+        Params::Fetch: ReadOnlySystemParamFetch,
+        Marker: 'static,
+    {
+    }
+}
+
+pub mod helper {
+    use crate::schedule_v3::{State, Statelike};
+    use crate::system::{Res, Resource};
+
+    /// Generates a [`Condition`]-satisfying closure that returns `true`
+    /// if the resource exists.
+    pub fn resource_exists<T>() -> impl FnMut(Option<Res<T>>) -> bool
+    where
+        T: Resource,
+    {
+        move |res: Option<Res<T>>| res.is_some()
+    }
+
+    /// Generates a [`Condition`]-satisfying closure that returns `true`
+    /// if the resource is equal to `value`.
+    ///
+    /// # Panics
+    ///
+    /// The condition will panic if the resource does not exist.
+    pub fn resource_equals<T>(value: T) -> impl FnMut(Res<T>) -> bool
+    where
+        T: Resource + PartialEq,
+    {
+        move |res: Res<T>| *res == value
+    }
+
+    /// Generates a [`Condition`]-satisfying closure that returns `true`
+    /// if the resource exists and is equal to `value`.
+    pub fn resource_exists_and_equals<T>(value: T) -> impl FnMut(Option<Res<T>>) -> bool
+    where
+        T: Resource + PartialEq,
+    {
+        move |res: Option<Res<T>>| match res {
+            Some(res) => *res == value,
+            None => false,
+        }
+    }
+
+    /// Generates a [`Condition`]-satisfying closure that returns `true`
+    /// if the state machine exists.
+    pub fn state_exists<S: Statelike>() -> impl FnMut(Option<Res<State<S>>>) -> bool {
+        move |current_state: Option<Res<State<S>>>| current_state.is_some()
+    }
+
+    /// Generates a [`Condition`]-satisfying closure that returns `true`
+    /// if the state machine is currently in `state`.
+    ///
+    /// # Panics
+    ///
+    /// The condition will panic if the resource does not exist.
+    pub fn state_equals<S: Statelike>(state: S) -> impl FnMut(Res<State<S>>) -> bool {
+        move |current_state: Res<State<S>>| current_state.0 == state
+    }
+
+    /// Generates a [`Condition`]-satisfying closure that returns `true`
+    /// if the state machine exists and is currently in `state`.
+    pub fn state_exists_and_equals<S: Statelike>(
+        state: S,
+    ) -> impl FnMut(Option<Res<State<S>>>) -> bool {
+        move |current_state: Option<Res<State<S>>>| match current_state {
+            Some(current_state) => current_state.0 == state,
+            None => false,
+        }
+    }
+}