borrowing check violations within nested loops

[hasikill]

I'm a Rust beginner, and I'm attempting to write a simple 2D collision example in Bevy using a mindset from another language. However, I'm encountering borrowing check violations within nested loops. I'm wondering how to express similar code in Bevy.
Below is my collision detection code:

fn apply_collisions(mut query: Query<(Entity, &mut Ball), With<Ball>>) {
    for (entity1, mut ball1) in query.iter_mut() {
        for (entity2, mut ball2) in query.iter_mut() {
            if entity1 != entity2 {
                let diff = ball1.position - ball2.position;
                let dist = diff.length();

                if dist < ball1.radius + ball2.radius {
                    let t = diff.normalize();
                    let delta = ball1.radius + ball2.radius - dist;
                    ball1.position = ball1.position + t.mul(0.5 * delta);
                    ball2.position = ball2.position + t.mul(-0.5 * delta);
                }
            }
        }
    }
}

[nicopap]

Bevy provides the iter_combinations_mut method. You should use it.

iter_combinations_mut basically exists for this exact use-case. Otherwise it would be impossible to do what you are doing.

Check the following example for some ready-made code:

bevy/examples/ecs/iter_combinations.rs

Lines 148 to 161 in 1c5c947

	fn interact_bodies(mut query: Query<(&Mass, &GlobalTransform, &mut Acceleration)>) {
	let mut iter = query.iter_combinations_mut();
	while let Some([(Mass(m1), transform1, mut acc1), (Mass(m2), transform2, mut acc2)]) =
	iter.fetch_next()
	{
	let delta = transform2.translation() - transform1.translation();
	let distance_sq: f32 = delta.length_squared();
	let f = GRAVITY_CONSTANT / distance_sq;
	let force_unit_mass = delta * f;
	acc1.0 += force_unit_mass * *m2;
	acc2.0 -= force_unit_mass * *m1;
	}
	}

[hasikill]

Thank you! It's all good now.