Best way to chain systems?

[SpomJ]

So what I need now is just to chain systems like function calls. But I really can't decide which one to choose. Here's the list of what I have come up with.

Ideally there just would be something like commands.run_system(func), but it doesn't seem the case here.

Functions

I could make the sub-systems just regular functons, but this has several downsides:

• I need to request whatever the child system needs through a parent function, which, to say, isn't that fancy and will result in a lot of params existing just to pass them to the child.
• Ideally I should also be able to execute them outside of that system, hence the reason I separated them in the first place. And again it's a query hell.

Events

I could also make use of events. However I need the data got from the previous system to properly execute the next one. I could also make a ton of events and call them one-by-one from each system. This, however also is bad because these execute frame-by-frame (the next is executed the next frame) and result in noticable chains. And even then sometimes something just fails and the data still doesn't get written by the time system is executed.

Stages

I could combine events and stages to hopefully get better results. However this still doesn't fully apply to my use case. Imagine I register the system in the second-after-update stage, but somewhere in the code I realize one of the chains is longer, so I need to go and insert a new stage (which isn't a pleasant experience either).

So what do you think? I currently sticked with the slow event system, but even there it seems i use events wrong. I might misunderstand something, in that case you can point it out.

[nicopap]

Assuming you are aware of the (sys1, sys2, sys3).chain() combinator as in the ecs_guide.rs example, and you are asking for a way to run systems outside of the regular scheduling system. You need exclusive world access for this.

1. Create a schedule with the systems in question in it
2. Run the schedule on the world

The transform system tests are a good example of this:

bevy/crates/bevy_transform/src/systems.rs

Lines 203 to 220 in 80db794

	let mut schedule = Schedule::new();
	schedule.add_systems((sync_simple_transforms, propagate_transforms));
	let mut command_queue = CommandQueue::default();
	let mut commands = Commands::new(&mut command_queue, &world);
	let root = commands.spawn(offset_transform(3.3)).id();
	let parent = commands.spawn(offset_transform(4.4)).id();
	let child = commands.spawn(offset_transform(5.5)).id();
	commands.entity(parent).set_parent(root);
	commands.entity(child).set_parent(parent);
	command_queue.apply(&mut world);
	schedule.run(&mut world);
	assert_eq!(
	world.get::<GlobalTransform>(parent).unwrap(),
	&offset_global_transform(4.4 + 3.3),
	"The transform systems didn't run, ie: `GlobalTransform` wasn't updated",
	);

In this particular case, you still want the systems to be properly ordered, so the Schedule constructor line would look like:

 schedule.add_systems((sync_simple_transforms, propagate_transforms).chain()); 

[SpomJ]

Assuming you are aware of the (sys1, sys2, sys3).chain() combinator as in the ecs_guide.rs example

Thanks, I was not.

However, this is still externally managed as far as I can tell. The main problem with my setup is that I (currently) have two functions:
I have a set of positions and the first one generates it;
The second one syncs entities with the said positions;
And there's also the one that triggers the whole thing.
So I guess I'll stick with events+chain.

[nicopap]

Consider using run conditions as well. You can have a system that returns a bool and add it as a condition with run_if.

app.add_systems(
  Update,
  (generate_positions, sync_entities_new_positions)
    .chain()
    .run_if(must_generate_positions)
)
// ...
fn must_generate_positions(query: Query<&Foo>) -> bool {
  query.iter().any(|foo| foo.requires_position_computation())
}

Also if you are having issues with entities spawned in generate_positions not being available in sync_entities_new_positions, consider adding apply_deferred. Like so:

app.add_systems(
  Update,
  (generate_positions, apply_deferred, sync_entities_new_positions)
    .chain()
    .run_if(must_generate_positions)
)

[nicopap]

You can also use system piping to read the output of sys1 in sys2 like so:

fn sys1(query: Query<&Foo>) -> Vec<Vec2> {
  // ... return a `Vec<Vec2>`
}
fn sys2(positions: In<Vec<Vec2>>, mut query: Query<&mut Bar>) {
  // use both `query` and `positions` to do things
}
// ...
app.add_systems(
  Update,
  sys1.pipe(sys2)
)

[SpomJ]

oh, thanks