Mutate two components of a query at the same time

[100-TomatoJuice]

I am new to Rust and Bevy, and I am trying to make a falling sand simulator and need to swap cell positions at the same time. I have achieved the swap in C# but Rust's borrow checker is making swapping harder as I can not access two items in a query at the same time.

This is a simplified version of the movement loop

pub fn update_movable_solid_positions(element_query: Query<&mut Element, With<MovableSolid>>) {
    for mut element in element_query.iter_mut() {
        if try_move(&mut element, element_query.iter().find(|x| x.position == Position {x: element.position.x, y: element.position.y - 1}).as_mut(), -1, 0) == false {
            // Rest of movment code
        }
    }
}

The try_move method takes in two elements: one is the current element, the second is the element where the current one is going to move

fn try_move(element: &mut Element, other_element: Option<&mut Element>, vertical_direction: i32, horizontal_direction: i32) -> bool{
    let x_position = element.position.x as i32 + horizontal_direction;
    let y_position = element.position.y as i32 + vertical_direction;

    if is_within_bounds(x_position, y_position) == false{
        return false;
    }
    
    // If there is no element in the position, then move there
    if other_element.is_none(){
        element.update_position(x_position as u32, y_position as u32);
        
        return true;
    }
    // If there is an element and this is more dense, then swap positions
    else if other_element.unwrap().density < element.density{
        let other_element = other_element.unwrap();
        swap_positions(element, other_element);
       
        return true;
    }

    false
}

The compile error, "cannot borrow 'element_query' as immutable because it is also borrowed as mutable," occurs in the for mut element in element_query.iter_mut() loop.

I understand the error, but I can not figure out a way around it. How can I access both elements in the query at the same time without the compile error?

[nicopap]

You need to store your position differently. I suggest one of the following:

• use a different component for position. Here you are struggling because position is a field of Element, while really it should be its own component. This way you can figure out neighbours without requiring access to Element, which prevents mutating it. I suggest a Query<(Entity, &Position), With<MovableSolid>>
• Ideally, to avoid having to iterate over all entities to find neighbours, you should store position -> Entity map or grid of entities in a Res.

Then, in your system, get the pair (Entity, Entity) for each falling element and potential target, and use the Query::get_many_mut method. Then you can do:

let Ok([falling_element, other_element]) = query.get_many_mut([falling_entity, other_entity]);

And you can feed that to your try_move. You'll have to do a bit more gymnastic to handle the None case on other_element, but that's the way of doing it.

[100-TomatoJuice]

I went with the grid of entities for performance reasons. I also separated the Position component from Element. Thank you for the answer, as it's helped me understand ECS better as well.