The behavior of Query seems to have some issues under concurrent conditions.

[Endoctrine]

I try the following code:

use bevy::app::{App, FixedUpdate, Startup};
use bevy::prelude::*;

#[derive(Component)]
struct Actor;

#[derive(Component)]
struct Attack;

#[derive(Component)]
struct AttackRestrain;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, setup)
        .add_systems(FixedUpdate, (give, get))
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn(Actor);
}

fn give(query: Query<(Entity, Option<&AttackRestrain>), With<Actor>>, mut commands: Commands) {
    for (entity, attack_restrain) in query.iter() {
        println!("a");
        if let None = attack_restrain {
            println!("b");
            commands.entity(entity).insert(Attack);
        }
        println!("c");
    }
}

fn get(query: Query<Entity, (With<Actor>, With<Attack>)>, mut commands: Commands) {
    for entity in query.iter() {
        println!("1");
        commands.entity(entity).insert(AttackRestrain).remove::<Attack>();
        println!("2");
    }
}

As you can see, there is not chain() after give and get. In this case, Query in get may obtain entities within two consecutive frames as follows:

2024-03-18T15:09:10.584773Z  INFO bevy_winit::system: Creating new window "App" (0v1)    
2024-03-18T15:09:11.002921Z  INFO bevy_render::renderer: AdapterInfo { name: "NVIDIA GeForce RTX 3070 Laptop GPU", vendor: 4318, device: 9437, device_type: DiscreteGpu, driver: "NVIDIA", driver_info: "528.49", backend: Vulkan }
a
b
c
1
2
a
b
c
1
2
a
c
a
c
...

But if get has already been executed once, letter b should not be printed by give the second time. As AttackRestrain has been inserted.

On the other hand, if there is a chain after give and get, everything seems to be right.

I'm wondering if my understanding of the ECS is not thorough enough.

[SkiFire13]

From what I can see this is what happens:

• First iteration:
  • the entity has no AttackRestraint, so give enqueues a command to add Attack to it
  • the entity has no Attack (yet), so get doesn't do anything
  • result: a b c is printed
  • Attack is then added by the enqueued command
• Second iteration:
  • the entity has no AttackRestraint, so give enqueues a command to add Attack to it (again)
  • the entity has Attack, so get enqueues a command to add AttackRestraint and remove Attack
  • result: 1 2 a b c is printed
  • the order of the two command is not guaranteed, but it seems get's command runs first and get runs second, with the result that AttackRestraint is added, Attack is removed, and then Attack is re-added, resulting in only AttackRestraint being added
• Third iteration:
  • the entity has AttackRestraint, so give does nothing
  • the entity has Attack, so get enqueues a command to add AttackRestraint and remove Attack
  • result: 1 2 a c is printed
  • Attack is then removed
• Fourth iteration (as all the following ones):
  • the entity has AttackRestraint, so `give does nothing
  • the entity has no Attack, so get does nothing
  • result: a c is printed

Overall I think the behaviour is expected, just not intuitive. Both systems and commands can run in any order, and systems are not guaranteed to see the result of commands of other systems unless they are relatively ordered (as you noticed when you put a .chain() between them).

[Endoctrine]

After your explanation, it seems like I have understood. During the second iteration, the Query occurs first, while the insert happens afterward. Therefore, even though the body of the get function executes earlier than that of the give function, give still receives a None.

Thank you, my friend.