Deprecate add_systems and instead make system types (Startup, Update, FixedUpdate, etc) into events / observers

[TheKnarf]

It feels like Bevy is growing to have a bunch of overlapping concepts where they perhaps don't need them. Why not make all systems into observers and simplify it a bit?

Systems

So instead of something like:

pub(super) fn plugin(app: &mut App) {
  app.add_systems(Startup, startup_function);
}

fn startup_function(mut commands: Commands) {
  todo!();
}

Just have:

pub(super) fn plugin(app: &mut App) {
  app.observe(startup_function);
}

fn startup_function(_trigger: Trigger<Startup>, mut commands: Commands) {
  todo!();
}

This would mean that there is one less concept for people to learn.

Plugins

In the same lane maybe plugins could also just be observers, something like:

fn main() -> AppExit {
    App::new()
       .observe(plugin)
       .run()
}

fn plugin(trigger: Trigger<PreStartup>, mut commands: Commands) {
  let event = trigger.event();
 
  event.app.observe(startup_function);
}

fn startup_function(_trigger: Trigger<Startup>, mut commands: Commands) {
  todo!();
}

Final note

Inspired a bit by how in frameworks like React everything is an React component, instead of having separate concepts for plugins, systems and observers.

And finally maybe observe could be renamed to just add.

[alice-i-cecile]

Systems and observers have different performance characteristics and schedule strategies! Both have their place, and neither is a complete replacement for the other :)

Systems are run periodically (typically once per frame), operate on many entities at once, and can be evaluated in parallel. They're good for performing large batches of work with predictable scheduling needs.

Observers on the other hand require exclusive world access, aren't run in parallel (which is both good and bad!) and can be queued up endlessly to respond to chained reactions. They're great for complex but lightweight cascades of tasks.