如何在Bevy ECS中嵌套迭代Query并解决可变借用冲突？

问题场景 #

你在开发Bevy ECS项目时，尝试在系统中嵌套迭代实体（外层迭代粒子，内层再次迭代粒子处理交互），遇到了可变借用冲突的错误。当前代码如下：

pub fn move_particles(
    time: Res<Time>,
    mut particles1: Query<(Entity, &mut Particle, &mut Transform)>,
    mut particles2: Query<(Entity, &mut Particle, &mut Transform), Without<Particle>>,
) {
    
    let bounds = Vec2::new(WINDOW_SIZE.x, WINDOW_SIZE.y);
    for (e, mut particle1, mut transform1) in particles1.iter_mut() {
        particle1.update();
        transform1.translation += particle1.velocity * time.delta_secs();

        if transform1.translation.x < -bounds.x || transform1.translation.x > bounds.x {
            particle1.velocity.x *= -1.0;
        }
        if transform1.translation.y < -bounds.y || transform1.translation.y > bounds.y {
            particle1.velocity.y *= -1.0;
        }
    }

    for (e1, mut particle1, mut transform1) in particles1.iter_mut() {
        for (e2, mut particle2, mut transform2) in particles2.iter_mut() {
            if PartialEq::eq(&e1, &e2){
                continue;
            }
            let distance = transform1.translation.distance(transform2.translation);
            let influence_radius = f32::min(particle1.influence_radius, particle2.influence_radius);

            if distance < influence_radius && distance > 1.0 {
                let direction = (transform2.translation - transform1.translation).normalize();
                let force = Particle::calculate_magnetic_force(particle1.color, particle2.color);
                let attraction = direction * force * time.delta_secs();

                particle1.velocity += attraction;
                particle2.velocity -= attraction;
            }
        }
    }
}

运行时抛出错误：

Cannot borrow 'particles' as mutable more than once at a time

错误原因 #

1. 无效的查询条件：particles2 使用了 Without<Particle>，但查询本身包含 &mut Particle，这会导致该查询永远返回空结果——没有实体能同时拥有和不拥有Particle组件。
2. 可变借用冲突：即使修正查询条件，嵌套迭代同一实体集合的可变引用时，Bevy的安全机制会阻止多次可变借用同一查询，避免数据竞争和状态不一致。

解决方案 #

方法一：使用ParamSet安全复用查询 #

ParamSet是Bevy提供的工具，允许你在同一系统中对同一查询进行多次可变访问，只要每次访问属于不同的"组"。

修正后的代码：

use bevy::ecs::system::ParamSet;

pub fn move_particles(
    time: Res<Time>,
    mut particles: ParamSet<(
        Query<(Entity, &mut Particle, &mut Transform)>,
        Query<(Entity, &mut Particle, &mut Transform)>,
    )>,
) {
    let bounds = Vec2::new(WINDOW_SIZE.x, WINDOW_SIZE.y);
    
    // 第一阶段：更新粒子位置和边界反弹
    for (e, mut particle, mut transform) in particles.p0().iter_mut() {
        particle.update();
        transform.translation += particle.velocity * time.delta_secs();

        if transform.translation.x < -bounds.x || transform.translation.x > bounds.x {
            particle.velocity.x *= -1.0;
        }
        if transform.translation.y < -bounds.y || transform.translation.y > bounds.y {
            particle.velocity.y *= -1.0;
        }
    }

    // 第二阶段：处理粒子间交互
    for (e1, mut particle1, transform1) in particles.p0().iter_mut() {
        for (e2, mut particle2, transform2) in particles.p1().iter_mut() {
            if e1 == e2 {
                continue;
            }
            let distance = transform1.translation.distance(transform2.translation);
            let influence_radius = f32::min(particle1.influence_radius, particle2.influence_radius);

            if distance < influence_radius && distance > 1.0 {
                let direction = (transform2.translation - transform1.translation).normalize();
                let force = Particle::calculate_magnetic_force(particle1.color, particle2.color);
                let attraction = direction * force * time.delta_secs();

                particle1.velocity += attraction;
                particle2.velocity -= attraction;
            }
        }
    }
}

方法二：拆分系统（更符合ECS设计理念） #

把粒子移动和粒子交互拆分成两个独立的系统，每个系统只需要一次可变借用，从根源避免冲突：

// 系统1：更新粒子位置和边界反弹
pub fn update_particle_positions(
    time: Res<Time>,
    mut particles: Query<(&mut Particle, &mut Transform)>,
) {
    let bounds = Vec2::new(WINDOW_SIZE.x, WINDOW_SIZE.y);
    for (mut particle, mut transform) in particles.iter_mut() {
        particle.update();
        transform.translation += particle.velocity * time.delta_secs();

        if transform.translation.x < -bounds.x || transform.translation.x > bounds.x {
            particle.velocity.x *= -1.0;
        }
        if transform.translation.y < -bounds.y || transform.translation.y > bounds.y {
            particle.velocity.y *= -1.0;
        }
    }
}

// 系统2：处理粒子间磁力交互
pub fn handle_particle_interactions(
    time: Res<Time>,
    mut particles: ParamSet<(
        Query<(Entity, &mut Particle, &Transform)>,
        Query<(Entity, &mut Particle, &Transform)>,
    )>,
) {
    for (e1, mut particle1, transform1) in particles.p0().iter_mut() {
        for (e2, mut particle2, transform2) in particles.p1().iter_mut() {
            if e1 >= e2 { // 避免重复处理同一对粒子，优化性能
                continue;
            }
            let distance = transform1.translation.distance(transform2.translation);
            let influence_radius = f32::min(particle1.influence_radius, particle2.influence_radius);

            if distance < influence_radius && distance > 1.0 {
                let direction = (transform2.translation - transform1.translation).normalize();
                let force = Particle::calculate_magnetic_force(particle1.color, particle2.color);
                let attraction = direction * force * time.delta_secs();

                particle1.velocity += attraction;
                particle2.velocity -= attraction;
            }
        }
    }
}

然后在App中注册这两个系统：

App::new()
    // ...其他设置
    .add_system(update_particle_positions.before(handle_particle_interactions))
    .add_system(handle_particle_interactions);

额外优化：避免重复计算 #

在嵌套迭代中，每对粒子会被处理两次（(e1,e2)和(e2,e1)），可以通过e1 < e2的判断跳过重复处理，减少一半的计算量，提升性能。

内容的提问来源于stack exchange，提问作者Michael