How can you detect collision among one group of objects? (2d)

[visualcode-t]

I have a component that may collide with other components of the same type. I can detect this by doing a nested query.iter(). But, then once the collision is detected I am stuck with immutable objects. What's the proper way to detect this collision and take action based on the result?

[Sheepyhead]

You may want to look at the rapier Plugin for bevy. It also has physics simulation, but you can use just the collision detection

[visualcode-t]

I'll look into Rapier. Is there no other way? I was thinking something with commands.Entity() but it didn't seem to have any options outside of despawn.

[Sheepyhead]

There are many ways to approach implementing collision detection but if you're stuck at this stage I'd honestly recommend just using rapier. Implementing collision is not trivial

[Jazarro]

It sounds like the question isn't so much about collision detection as it is about conflicting queries.

If you need multiple queries sharing mutable borrows to the same component type, you need a ParamSet. In bevy 0.8.1 there aren't any examples specifically about the ParamSet, though you can see it being used in the tools/scene_viewer example. It looks like this:

mut queries: ParamSet<(
    Query<&mut Text, With<HeroProficiencyDisplay>>,
    Query<&mut Text, With<HeroDamageResDisplay>>,
)>,

if let Ok(mut text) = query.p0().get_single_mut() {}
if let Ok(mut text) = query.p1().get_single_mut() {}

Note that you still cannot use these queries at the same time, because that would be potentially unsafe. Instead, you could perhaps use your first query to retrieve the entity that is being collided with, return it from the iterator through a find() or something and then run your second query to mutate it.

[visualcode-t]

So, I have a solution, but it just feels a bit awkward:

fn rain(mut commands: Commands, mut query_rain: Query<(Entity,&mut Transform, &mut Sprite), With<Rain>>,query_objs:Query<(Entity,&mut Transform,&mut Sprite),Without<Rain>>,windows: Res<Windows>) {
    let window = windows.get_primary().expect("Failed to retrieve window information (rain)");
    let mut full_set = Vec::<(Entity,Transform,Sprite,bool)>::new();
    for mut rain_drop in query_rain.iter_mut() {
        full_set.push((rain_drop.0,rain_drop.1.clone(),rain_drop.2.clone(),true));
    }
    for obj in query_objs.iter() {
        full_set.push((obj.0,obj.1.clone(),obj.2.clone(),false));
    }
    for mut rain_drop in query_rain.iter_mut() {
        let mut crash = false;
        for item in full_set.clone() {
            if item.0.id() != rain_drop.0.id() {
                if let Some(_) = collide(item.1.translation, item.2.custom_size.expect(""), rain_drop.1.translation, rain_drop.2.custom_size.expect("")) {  
                    crash = true;
                }
            }
        }
        if crash == false {
            todo()!
        }
    }
}

Basically, I have to catalog all Rain objects and all non-Rain objects. Then, I can run through them one by one to check for collision. It just feels like there should be a better way.

[Jazarro]

I want to preface this by saying that it might be better to use a physics engine like rapier, I don't know, it depends on the use case. Either way, I'm going to ignore it, since I haven't worked with it before.

What are you trying to do here? What are you going to mutate, the rain drop or the thing it collides with, or both? In general, if you don't need mutable access to a component, query it as a regular borrow instead of a mutable borrow.

Are you sure you need to check for collision between rain drops? They usually move parallel to each other, so there probably wouldn't be any collisions at all. You might get away with just not checking for it at all, thereby greatly decreasing the number of collision checks you need to do.

Calling .clone() that often is an anti-pattern, especially for more complex objects. In particular, if you're cloning a boxed object you need to clear space on the heap all the time, that's probably a bad thing. A lot of the time you can get away with borrows instead.

[tim-blackbird]

Prehaps iter_combinations_mut is what you're looking for.

fn rain(
    mut query_rain: Query<(Entity, &mut Transform, &mut Sprite), With<Rain>>,
    query_objs: Query<(Entity, &Transform, &Sprite), Without<Rain>>,
) {

    let mut iter = query_rain.iter_combinations_mut();
    while let Some([mut rain_drop_a, mut rain_drop_b]) = iter.fetch_next() {
        // Handle collisions between entities with Rain.
    }

    for mut rain_drop in &mut query_rain {
        for item in &query_objs {
            // Handle collisions with entities without Rain.
        }
    }
}

[visualcode-t]

This is it! Thank you.