如何在Bevy系统中执行嵌套查询？

如何解决如何在Bevy系统中执行嵌套查询？

我正在用Bevy制作一个小小的boids玩具，每个物体的速度/加速度取决于周围物体的位置和速度值。这意味着对于每个投标，我都希望运行一些依赖于其他投标的子集的逻辑。

这似乎基本上可以是嵌套的for循环：

for boid in boids {
    for other_boid in boids {
        if boid.id == other_boid.id {
            continue;
        }
        
        if boid.position.distance_to(other_boid.position) < PERCEPTION_DISTANCE {
            // change boid's velocity / acceleration
        }
    }
}

但是，我不确定如何使用Bevy中的查询执行此操作。假设我有一个系统move_boids：

fn move_boids(mut query: Query<&Boid>) {
    for boid in &mut query.iter() {
        // I can't iterate over *other* boids here
    }
}

我收到类似这样的错误，因为我在两个循环中都是可变地借用query：

error[E0499]: cannot borrow `query` as mutable more than once at a time
  --> src\main.rs:10:32
   |
10 |     for boid in &mut query.iter() {
   |                      ------------
   |                      |          |
   |                      |          ... and the first borrow might be used here,when that temporary is dropped and runs the `Drop` code for type `bevy::bevy_ecs::system::query::QueryBorrow`
   |                      first mutable borrow occurs here
   |                      a temporary with access to the first borrow is created here ...
...
11 |         for other_boid in &mut query.iter() {}
   |                                ^^^^^ second mutable borrow occurs here

我无法在同一查询上进行嵌套迭代，因此我不确定获取有关每个投标周围投标的信息的最佳方法。我是否应该将第一个查询中每个主体的位置和速度信息复制到HashMap<Entity,BoidData>中，然后在其中进行查找？我还能做些惯用的事吗？

解决方法

所以我想出了一个非常微妙的答案，而且我不确定它是否可以很好地适用于投标。您尝试执行的操作由于在同一范围内有两个可变引用而无法使用。

我能够获得其他投标，并使用Vec<u128>的投标进行比较。我不会使用哈希图，因为我听说它们的查找速度较慢，但​​是我没有尝试过。

在我的示例中，我假设boid的数量恒定，但是您可以使用boid向量的长度。我还为示例制作了一个随机boid结构，并使用了rand。

const NUM_BOIDS: u32 = 10;
struct Boids(Vec<u128>);
struct Boid {
    position: f32,velocity: f32,}
fn main() {
    App::build()
        ...
        .add_resource(Boids(Vec::new()))
        ...
}

fn setup(mut commands: Commands,mut boids: ResMut<Boids>) {
    let mut rng = rand::thread_rng();
    for i in 0..10 {
        // create 10 boids,and add there id's to the boids vec
        if let Some(entity) = commands
            .spawn((Boid {
                position: rng.gen_range(0.0,100.0),velocity: rng.gen_range(0.0,25.0),},))
            .current_entity()
        {
            boids.0.push(entity.id());
        };
    }
}

fn get_boids(mut boids: ResMut<Boids>,mut query: Query<(Entity,&mut Boid)>) {
    // go through all the boid ids
    for (i,boid_id) in boids.0.iter().enumerate() {
        // go through a second time
        for j in 0..NUM_BOIDS {
            // this gets the next boid id unless its at the end
            let other_boid_id = match boids.0.get(j as usize..(j as usize + 1)) {
                Some(e) => e,None => {
                    continue;
                }
            };
            // skip if it is the same boid
            if *boid_id == other_boid_id[0] {
                continue;
            }
            
            // since you can't have two mutable references at the same time
            // this gets the positions so those can be compared
            // and if the statement is true,a mutable reference can be gotten again.
            let mut first_position = 0.0;
            {
                let en = Entity::from_id(*boid_id);
                let first_boid: RefMut<Boid> = query.get_mut::<Boid>(en).unwrap();
                first_position = first_boid.position.clone();
            }
            let mut second_position = 0.0;
            {
                let en2 = Entity::from_id(other_boid_id[0]);
                let second_boid: RefMut<Boid> = query.get_mut::<Boid>(en2).unwrap();
                second_position = second_boid.position.clone();
            }
            if first_position - second_position < 0.001 {
                let en = Entity::from_id(*boid_id);
                let mut first_boid: RefMut<Boid> = query.get_mut::<Boid>(en).unwrap();
                first_boid.velocity = 15.0;
            }
        }
    }
}