From 178b3078dd22f5447ab6620b3a45ca8ab80eeb0b Mon Sep 17 00:00:00 2001
From: Mike Hsu <mike.hsu@gmail.com>
Date: Sun, 17 Dec 2023 21:30:08 -0800
Subject: [PATCH 1/4] add a generic over SystemParam

---
 examples/ecs/generic_system.rs | 63 ++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/examples/ecs/generic_system.rs b/examples/ecs/generic_system.rs
index dbd5b63432..7f69ac75f0 100644
--- a/examples/ecs/generic_system.rs
+++ b/examples/ecs/generic_system.rs
@@ -10,6 +10,7 @@
 //! or <https://doc.rust-lang.org/rust-by-example/generics.html>
 
 use bevy::prelude::*;
+use system_with_generic_system_param::*;
 
 #[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, States)]
 enum AppState {
@@ -40,6 +41,8 @@ fn main() {
             (
                 print_text_system,
                 transition_to_in_game_system.run_if(in_state(AppState::MainMenu)),
+                system_with_generic::<ResMut<ResourceA>>,
+                system_with_generic::<ResMut<ResourceB>>,
             ),
         )
         // Cleanup systems.
@@ -87,3 +90,63 @@ fn cleanup_system<T: Component>(mut commands: Commands, query: Query<Entity, Wit
         commands.entity(e).despawn_recursive();
     }
 }
+
+mod system_with_generic_system_param {
+    use super::*;
+    use bevy::ecs::system::{SystemParam, SystemParamItem};
+
+    pub trait MyTrait {
+        fn calculate_something(&mut self) {}
+    }
+
+    #[derive(Resource)]
+    pub struct ResourceA(pub usize);
+
+    impl MyTrait for ResMut<'_, ResourceA> {
+        fn calculate_something(&mut self) {
+            // dbg!(self.0);
+            self.0 = 5;
+        }
+    }
+
+    #[derive(Resource)]
+    pub struct ResourceB(pub usize);
+    impl MyTrait for ResMut<'_, ResourceB> {
+        fn calculate_something(&mut self) {
+            // dbg!(self.0);
+            self.0 = 10;
+        }
+    }
+
+    pub fn system_with_generic<S: SystemParam>(mut param: SystemParamItem<S>)
+    where
+        for<'w, 's> S::Item<'w, 's>: MyTrait,
+    {
+        param.calculate_something();
+    }
+}
+
+mod system_param_in_associated_type {
+    use super::*;
+    use bevy::ecs::system::{lifetimeless::SRes, StaticSystemParam, SystemParam, SystemParamItem};
+
+    #[derive(Resource)]
+    struct ResourceA;
+
+    pub trait MyTrait {
+        type Param: SystemParam + 'static;
+
+        fn do_something(&self, param: &mut SystemParamItem<Self::Param>) -> u32;
+    }
+
+    struct ItemA;
+    impl MyTrait for ItemA {
+        type Param = SRes<ResourceA>;
+
+        fn do_something(&self, param: &mut SystemParamItem<Self::Param>) -> u32 {
+            todo!()
+        }
+    }
+
+    fn system<S: MyTrait>(param: StaticSystemParam<<S as MyTrait>::Param>) {}
+}

From c21e4063167d45250e5cdabad6da18abd49b9fd9 Mon Sep 17 00:00:00 2001
From: Mike Hsu <mike.hsu@gmail.com>
Date: Sun, 11 Feb 2024 11:29:51 -0800
Subject: [PATCH 2/4] clean up associated type

---
 examples/ecs/generic_system.rs | 28 ++++++++++++++++++++++------
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/examples/ecs/generic_system.rs b/examples/ecs/generic_system.rs
index 7f69ac75f0..f55bc440ce 100644
--- a/examples/ecs/generic_system.rs
+++ b/examples/ecs/generic_system.rs
@@ -10,6 +10,7 @@
 //! or <https://doc.rust-lang.org/rust-by-example/generics.html>
 
 use bevy::prelude::*;
+use system_param_in_associated_type::*;
 use system_with_generic_system_param::*;
 
 #[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, States)]
@@ -43,6 +44,7 @@ fn main() {
                 transition_to_in_game_system.run_if(in_state(AppState::MainMenu)),
                 system_with_generic::<ResMut<ResourceA>>,
                 system_with_generic::<ResMut<ResourceB>>,
+                system::<ItemA>,
             ),
         )
         // Cleanup systems.
@@ -64,6 +66,10 @@ fn setup_system(mut commands: Commands) {
         TextToPrint("I will always print".to_string()),
         LevelUnload,
     ));
+
+    commands.insert_resource(ResourceA(1));
+    commands.insert_resource(ResourceB(2));
+    commands.insert_resource(ResourceC { data: 3 });
 }
 
 fn print_text_system(time: Res<Time>, mut query: Query<(&mut PrinterTick, &TextToPrint)>) {
@@ -91,6 +97,7 @@ fn cleanup_system<T: Component>(mut commands: Commands, query: Query<Entity, Wit
     }
 }
 
+// For a more advanced usage you may want to be generic over a trait instead.
 mod system_with_generic_system_param {
     use super::*;
     use bevy::ecs::system::{SystemParam, SystemParamItem};
@@ -101,7 +108,6 @@ mod system_with_generic_system_param {
 
     #[derive(Resource)]
     pub struct ResourceA(pub usize);
-
     impl MyTrait for ResMut<'_, ResourceA> {
         fn calculate_something(&mut self) {
             // dbg!(self.0);
@@ -126,12 +132,15 @@ mod system_with_generic_system_param {
     }
 }
 
+// TODO: change this to be assets?
 mod system_param_in_associated_type {
     use super::*;
     use bevy::ecs::system::{lifetimeless::SRes, StaticSystemParam, SystemParam, SystemParamItem};
 
     #[derive(Resource)]
-    struct ResourceA;
+    pub struct ResourceC {
+        pub data: u32,
+    }
 
     pub trait MyTrait {
         type Param: SystemParam + 'static;
@@ -139,14 +148,21 @@ mod system_param_in_associated_type {
         fn do_something(&self, param: &mut SystemParamItem<Self::Param>) -> u32;
     }
 
-    struct ItemA;
+    #[derive(Resource)]
+    pub struct ItemA;
     impl MyTrait for ItemA {
-        type Param = SRes<ResourceA>;
+        // specifies that data needed by do_something
+        type Param = SRes<ResourceC>;
 
         fn do_something(&self, param: &mut SystemParamItem<Self::Param>) -> u32 {
-            todo!()
+            param.data
         }
     }
 
-    fn system<S: MyTrait>(param: StaticSystemParam<<S as MyTrait>::Param>) {}
+    pub fn system<S: MyTrait + Resource>(
+        mut param: StaticSystemParam<<S as MyTrait>::Param>,
+        asset: ResMut<S>,
+    ) {
+        asset.do_something(&mut param);
+    }
 }

From aaec4f3c3fa5a0895fce09a2dfb39054d1de212a Mon Sep 17 00:00:00 2001
From: Mike Hsu <mike.hsu@gmail.com>
Date: Sun, 3 Mar 2024 22:04:58 -0800
Subject: [PATCH 3/4] make generic system param example more realistic

---
 examples/ecs/generic_system.rs | 95 ++++++++++++++++++++++++----------
 1 file changed, 69 insertions(+), 26 deletions(-)

diff --git a/examples/ecs/generic_system.rs b/examples/ecs/generic_system.rs
index f55bc440ce..783b8d57d9 100644
--- a/examples/ecs/generic_system.rs
+++ b/examples/ecs/generic_system.rs
@@ -11,7 +11,6 @@
 
 use bevy::prelude::*;
 use system_param_in_associated_type::*;
-use system_with_generic_system_param::*;
 
 #[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, States)]
 enum AppState {
@@ -42,8 +41,6 @@ fn main() {
             (
                 print_text_system,
                 transition_to_in_game_system.run_if(in_state(AppState::MainMenu)),
-                system_with_generic::<ResMut<ResourceA>>,
-                system_with_generic::<ResMut<ResourceB>>,
                 system::<ItemA>,
             ),
         )
@@ -67,8 +64,6 @@ fn setup_system(mut commands: Commands) {
         LevelUnload,
     ));
 
-    commands.insert_resource(ResourceA(1));
-    commands.insert_resource(ResourceB(2));
     commands.insert_resource(ResourceC { data: 3 });
 }
 
@@ -97,42 +92,90 @@ fn cleanup_system<T: Component>(mut commands: Commands, query: Query<Entity, Wit
     }
 }
 
-// For a more advanced usage you may want to be generic over a trait instead.
+// For a more advanced usage you may want have a group of system params to implement a trait.
+// Note that this example is a little contrived in the interest of keeping things simple. The
+// purpose here is to demontrate how to get the traits and lifetimes to work properly.
 mod system_with_generic_system_param {
     use super::*;
-    use bevy::ecs::system::{SystemParam, SystemParamItem};
+    use bevy::ecs::system::SystemParam;
 
-    pub trait MyTrait {
-        fn calculate_something(&mut self) {}
-    }
-
-    #[derive(Resource)]
-    pub struct ResourceA(pub usize);
-    impl MyTrait for ResMut<'_, ResourceA> {
-        fn calculate_something(&mut self) {
-            // dbg!(self.0);
-            self.0 = 5;
+    struct DamagePlugin;
+    impl Plugin for DamagePlugin {
+        fn build(&self, app: &mut App) {
+            app.add_systems(Startup, setup_damage).add_systems(
+                Update,
+                (
+                    apply_damage::<PlayerDamageParams>,
+                    apply_damage::<EnemyDamageParams>,
+                ),
+            );
         }
     }
 
+    #[derive(Component)]
+    struct Player;
+
+    #[derive(Component)]
+    struct Enemy;
+
+    #[derive(Component)]
+    struct Health(f32);
+
     #[derive(Resource)]
-    pub struct ResourceB(pub usize);
-    impl MyTrait for ResMut<'_, ResourceB> {
-        fn calculate_something(&mut self) {
-            // dbg!(self.0);
-            self.0 = 10;
+    struct EnemySettings {
+        /// damage done by player to enemy
+        take_damage: f32,
+        /// damage done by enemy to player
+        do_damage: f32,
+    }
+
+    pub trait GetDamage {
+        fn apply_damage(&mut self) {}
+    }
+
+    #[derive(SystemParam)]
+    struct PlayerDamageParams<'w, 's> {
+        player: Query<'w, 's, &'static mut Health, With<Player>>,
+        enemy_settings: Res<'w, EnemySettings>,
+    }
+    impl<'w, 's> GetDamage for PlayerDamageParams<'w, 's> {
+        fn apply_damage(&mut self) {
+            let mut player_health = self.player.single_mut();
+            player_health.0 += self.enemy_settings.do_damage;
         }
     }
 
-    pub fn system_with_generic<S: SystemParam>(mut param: SystemParamItem<S>)
+    #[derive(SystemParam)]
+    struct EnemyDamageParams<'w, 's> {
+        enemies: Query<'w, 's, &'static mut Health, With<Enemy>>,
+        enemy_settings: Res<'w, EnemySettings>,
+    }
+    impl<'w, 's> GetDamage for EnemyDamageParams<'w, 's> {
+        fn apply_damage(&mut self) {
+            for mut enemy_health in self.enemies.iter_mut() {
+                enemy_health.0 -= self.enemy_settings.take_damage;
+            }
+        }
+    }
+
+    // Note that the param passed into a system is `SystemParam::Item` and not just `SystemParam`.
+    fn apply_damage<S: SystemParam>(mut param: S::Item<'_, '_>)
     where
-        for<'w, 's> S::Item<'w, 's>: MyTrait,
+        for<'w, 's> S::Item<'w, 's>: GetDamage,
     {
-        param.calculate_something();
+        param.apply_damage();
+    }
+
+    fn setup_damage(mut commands: Commands) {
+        commands.insert_resource(EnemySettings {
+            do_damage: 1.0,
+            take_damage: 2.0,
+        });
     }
 }
 
-// TODO: change this to be assets?
+// TODO: change this to use assets?
+// You may want to be have the SystemParam be specified in an associated type.
 mod system_param_in_associated_type {
     use super::*;
     use bevy::ecs::system::{lifetimeless::SRes, StaticSystemParam, SystemParam, SystemParamItem};

From fdc61ca408a1d40f69c299c8789ecff4e369ff74 Mon Sep 17 00:00:00 2001
From: Mike Hsu <mike.hsu@gmail.com>
Date: Sun, 3 Mar 2024 22:53:09 -0800
Subject: [PATCH 4/4] cleanup associate type example a bit more

---
 examples/ecs/generic_system.rs | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/examples/ecs/generic_system.rs b/examples/ecs/generic_system.rs
index 783b8d57d9..8b3aa8742a 100644
--- a/examples/ecs/generic_system.rs
+++ b/examples/ecs/generic_system.rs
@@ -174,12 +174,16 @@ mod system_with_generic_system_param {
     }
 }
 
-// TODO: change this to use assets?
 // You may want to be have the SystemParam be specified in an associated type.
 mod system_param_in_associated_type {
     use super::*;
     use bevy::ecs::system::{lifetimeless::SRes, StaticSystemParam, SystemParam, SystemParamItem};
 
+    #[derive(Resource)]
+    pub struct ResourceA {
+        pub data: u32,
+    }
+
     #[derive(Resource)]
     pub struct ResourceC {
         pub data: u32,
@@ -202,10 +206,22 @@ mod system_param_in_associated_type {
         }
     }
 
+    #[derive(Resource)]
+    pub struct ItemB;
+    impl MyTrait for ItemB {
+        // we can specify any system param here, including a combination of other system params
+        type Param = (SRes<ResourceA>, SRes<ResourceC>);
+
+        fn do_something(&self, param: &mut SystemParamItem<Self::Param>) -> u32 {
+            // todo: Make this more intelligible
+            param.0.data + param.1.data
+        }
+    }
+
     pub fn system<S: MyTrait + Resource>(
         mut param: StaticSystemParam<<S as MyTrait>::Param>,
-        asset: ResMut<S>,
+        item: ResMut<S>,
     ) {
-        asset.do_something(&mut param);
+        item.do_something(&mut param);
     }
 }