Added a generic systems example to the examples folder in bevy.

[AmrDhaliwal]

Hi @alice-i-cecile,

Sorry this took me so long but, here's the code could you take a look and let
me know if I am heading in the right direction.

Thanks!

[NathanSWard]

So far this seems like a good starting point!
However, it'll definitely need some fleshing out.

A few logistical things,

1. This will need to be added as an [[example]] in the primary Cargo.toml file
2. This will need to be added in the examples/README.md

Now with a few more suggestions

1. All example are runnable, meaning they have a fn main() associated with them so that a user is able to run the example.
   • So having a fn main() along with an App::build().add_system(MyGenericSystem::<T>.system()) will be needed.
2. Since this is covering generic system, we need to highlight the primary reason we'd use them. And that is re-usability.
   • So ideally, you would have 1 generic system, and then you would add it it at least 2 times to the primary application with a different generic type for each addition.

for example

struct A;
struct B;

fn system<T>(_: Query<&T>) {}

fn main() {
    App::build()
        .add_system(system::<A>.system())
        .add_system(system::<B>.system())
        .run();
}

3. While the remove_entity system you provided was a great start, there won't actually be an entities alive to remove making the system do nothing.
   • It would be nice to have the system do something the the user can view. Perhaps this is a spawn_entity<T>, or a log_component<T> for example.

Again great start and please ask if you have any questions along the way! 😄

[alice-i-cecile]

Awesome, thanks for contributing! You may also find this advice on writing examples helpful to you :)

Nathan's advice above is great. You'll need to use .add_system(my_system::<A>.system()) to get it to actually register though :p

I think it makes sense to think about when you want to use this pattern, and communicate that to users through your choice of example. To me, generic systems are useful when you need to perform the same operation on several distinct but similar component or resource types. In Bevy itself, we use it for events :) Coming up with those details is a lot of the fun of this work, but let us know if you'd like suggestions.

P.S. This fits nicely into the ecs folder of the examples, since it's just showcasing an advanced way to use systems.

[AmrDhaliwal]

Wow, thanks for all the advice and now I think I understand what the generic system should actually be doing.
I will go ahead and start working on them.

Thanks again!

[AmrDhaliwal]

Hi @alice-i-cecile,

I added the generic_systems to the examples for the README and Cargo.toml.
I was hoping you could take a look at the code and see if it is more in line than before.

Thanks!

[AmrDhaliwal]

Hi @alice-i-cecile and @NathanSWard,

I added mouse inputs in hopes that when either mouse left or right is clicked it would spawn an entity.
Would this be a good example?

[alice-i-cecile]

FYI @AmrDhaliwal, as a PR author on GitHub you can press "Resolve Conversation" on comments in this thread. This makes it easier to skim and see which concerns still need to be addressed :)

[alice-i-cecile]

This line and the one below don't seem to do anything?

[AmrDhaliwal]

@NathanSWard Hopefully I got this right.

[alice-i-cecile]

I think this needs the second type parameter to work :)

[AmrDhaliwal]

@alice-i-cecile do you mean the second parameter type for the function?

[Ratysz]

Hopefully I got this right.

That's... not really how this works. Have you tried running the example you wrote? It doesn't compile, because the syntax is incorrect.

I would also recommend using cargo fmt, whenever you compile or even just save the file.

[alice-i-cecile]

bors try

[bors]

try

Build failed:

• check-missing-examples-in-docs

[Weibye]

You will need to add the example to the examples/README.md in order for the CI to succeed :)

[alice-i-cecile]

I tried my hand at my own generic system example for the book. Working with UI is way too verbose for that though :(

Here's my almost-complete code; feel free to use or learn from it:

use bevy::{app::AppExit, prelude::*};

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_startup_system(spawn_buttons_system)
        // Events are automatically cleaned up using generic systems added with add_event!
        .add_event::<Hello>()
        .add_event::<Goodbye>()
        // This system operates on buttons with a Hello component
        .add_system(event_button_system::<Hello>)
        // But this one only operates on those with a Goodbye component
        .add_system(event_button_system::<Goodbye>)
        // We're not using generic systems for event handling]
        // because we need different behavior
        .add_system(hello_system)
        .add_system(goodbye_system)
        .run()
}

// We're using these as both a components
// and event types
#[derive(Clone)]
struct Hello {
    name: String,
}
#[derive(Clone)]
struct Goodbye;

fn spawn_buttons_system(mut commands: Commands) {
    // We need a UI camera so we can see our buttons
    commands.spawn_bundle(UiCameraBundle::default());

    // We're quickly building 3 buttons in a UI hierarchy
    // FIXME: add buttons
}

fn event_button_system<E: Send + Sync + Clone + 'static>(
    // Interaction is the built-in type used to
    // detect mouse interactions with buttons
    query: Query<(&E, &Interaction)>,
    mut writer: EventWriter<E>,
) {
    // By using & here we can avoid dereferencing our unpacked components later
    for (event_component, &interaction) in query.iter() {
        if interaction == Interaction::Clicked {
            // This will send any data stored in the component in the event as well
            writer.send(event_component.clone());
        }
    }
}

fn hello_system(mut reader: EventReader<Hello>) {
    for hello_event in reader.iter() {
        println!("Hello {}!", hello_event.name);
    }
}

// AppExit is a built-in event type that quits the app when it is received
fn goodbye_system(mut goodbye_reader: EventReader<Goodbye>, mut exit_writer: EventWriter<AppExit>) {
    if goodbye_reader.iter().count() > 0 {
        println!("Goodbye!");
        exit_writer.send(AppExit);
    }
}

[alice-i-cecile]

I'm going to close this out in favor of #2636 <3