2d Collision

[The-DevBlog]

I'm trying to implement my own collision for a basic 2d platformer. Below is my current (broken) collision system. In the match block, I tried to change the x & y of the player_transform to 0.0, but then I ran into some conflicting mutability rules. I also tried to play around with a QuerySet, but was unsuccessful. The Gravity component would ideally be removed from this function once I have it working.

fn collision(
    mut player_query: Query<(&Player, &Transform, &Sprite, &mut Gravity)>,
    collider_query: Query<(&Collider, &Transform, &Sprite)>,
) {
    if let Ok((_player, player_transform, player_sprite, mut gravity)) = player_query.single_mut() {
        let player_size = player_sprite.size;

        for (_collider, collider_transform, collider_sprite) in collider_query.iter() {
            let collision = collide(
                player_transform.translation,
                player_size,
                collider_transform.translation,
                collider_sprite.size,
            );

            // TODO: this isn't how I should stop the Y-velocity of player
            // causing issues with jumping
            // not preventing player from colliding into the sides of the an object
            if let Some(collision) = collision {
                match collision {
                    // placeholders
                    Collision::Left => gravity.0 = 0.0,
                    Collision::Right => gravity.0 = 0.0,
                    Collision::Bottom => gravity.0 = 0.0,
                    Collision::Top => gravity.0 = 0.0,
                }
            }
        }
    }
}

[alice-i-cecile]

Here's a snippet from my draft of the next version of the Bevy book. In your case, ensuring the queries are mutually exclusive using a Without filter should do the trick.

Running multiple queries at once

As the logic in your systems become more complex, you may find that you want to access data from two different queries at once.
In most cases, simply adding a second query as another system parameter works perfectly fine:

fn defense_aura_system(aura_query: Query<&Transform, With<Aura>>, target_query: Query<(&mut Defense, &Transform), With<Creature>>){
	// Give all allies near an aura-generator a bonus to their defense
}

But as you use this pattern more, you may encounter an error that looks something like:

   Query<&mut Transform, With<Camera>> in system move_player accesses component(s) &mut Transform in a way that conflicts with a previous system parameter. Allowing this would break Rust's mutability rules. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `QuerySet`.

What went wrong? It worked just fine before!

Well, it turns out that Rust, in its infinite wisdom,
does not like it when you access the same data in multiple places at once,
if at least one of those accesses is mutable.
That's a result of its ownership rules: we could mutate data in the first query while the second query is trying to read the data, resulting in undefined behavior.
Which is bad.

Of course, you already knew that, and have carefully thought about the architecture of your system, designing something like:

fn camera_follow_system(player_query: Query<&Transform, With<Player>>, camera_query: Query<&mut Transform, With<Camera>>){
	let player_transform = player_query.single().unwrap();
	let camera_query = camera_query.single_mut.unwrap();
	// Insert logic here
}

You know that there's never going to be an entity that has both Player and Camera on it, so there's no way that you're ever accessing the same Transform component twice.
Unfortunately, Rust doesn't know that.
We can fix this by making sure our queries our disjoint, no matter what bizarre entities might exist, through the judicious application of Without queries.

fn camera_follow_system(player_query: Query<&Transform, With<Player>>, camera_query: Query<&mut Transform, (With<Camera>, Without<Player>)>){
	let player_transform = player_query.single().unwrap();
	let camera_query = camera_query.single_mut.unwrap();
	// Insert logic here
}

The other way to get around this issue is to use a QuerySet, which permits multiple conflicting queries to exist in a single system.
The catch is that you can only access one query at a time.
Query sets can be useful when you need to access genuinely conflicting data, such as if we truly had an entity with both Player and Camera that we wanted to operate on in both loops of our system.
Let's rewrite our broken system again, using a QuerySet instead.

fn camera_follow_system(queries: QuerySet<Query<&Transform, With<Player>>, Query<&mut Transform, With<Camera>>){
	let player_transform = queries.0.single().unwrap();
	let camera_query = queries.1.single_mut.unwrap();
	// Insert logic here
}

[The-DevBlog]

Thank you! This clears up a lot. I can now modify contents of both queries with no ownership issues. Now to make the physics actually work lol.

[AndrewJakubowicz]

Thank you! This answer unblocked me and taught me a lot more about using Query & QuerySet.