How to rework this function taking a mutable World and making various mutations?

[bbarker]

I've been porting some specs ECS code to bevy's ecs, and currently i'm looking at rewriting this function:

pub fn try_move_player(ecs: &mut World, delta_x: i32, delta_y: i32) -> RunState {
    ecs.resource_scope(|ecs, mut map: Mut<Map>| {
        ecs.resource_scope(|ecs, mut log: Mut<GameLog>| {
            let mut query =
                ecs.query_filtered::<(Entity, &mut Position, &mut Viewshed), With<Player>>();
            let mut query_iter = query.iter_mut(ecs);
            // TODO: maybe move query iter here and collect changes to be mutated later
            // let log = ecs.resource_mut::<GameLog>();
            let mut combat_stats = ecs.query::<&CombatStats>();
            if let Some((entity, mut pos, mut viewshed)) = query_iter.next() {
                let try_pos = map.dest_from_delta(&*pos, delta_x, delta_y);
                let destination_ix = map.pos_idx(try_pos);
                let combat = map.tile_content[destination_ix]
                    .iter()
                    .filter(|potential_target| **potential_target != entity)
                    .any(|potential_target| {
                        if let Ok(_c_stats) = combat_stats.get(ecs, *potential_target) {
                            log.entries
                                .push("I stab thee with righteous fury!".to_string());
                            ecs.entity_mut(entity).insert(EventWantsToMelee {
                                target: *potential_target,
                            });
                            true
                        } else {
                            false
                        }
                    });
                if !combat && !map.blocked[destination_ix] {
                    map.move_blocker(&mut pos, &try_pos);
                    viewshed.dirty = true;
                    RunState::PlayerTurn
                } else if combat {
                    RunState::PlayerTurn
                } else {
                    RunState::AwaitingInput
                }
            } else {
                RunState::AwaitingInput
            }
        })
    })
}

However, I'm getting many errors related to mutably borrowing ecs multiple times, which has me feeling that I'm going against the grain. How would it be best to structure this in bevy?

[nicopap]

In this case you want to use a SystemState

It might end up looking like the following:

pub fn try_move_player(ecs: &mut World, delta_x: i32, delta_y: i32) -> RunState {
    // Construct a `SystemState` struct, passing in a tuple of `SystemParam`
    // as if you were writing an ordinary system.
    let mut system_state: SystemState<(
        ResMut<Map>,
        ResMut<GameLog>,
        Query<(Entity, &mut Position, &mut Viewshed), With<Player>>,
        Query<&CombatStats>,
    )> = SystemState::new(&mut ecs);
    let (
        mut map,
        mut log,
        mut query,
        combat_stats,
    ) = system_state.get_mut(&mut ecs);

    if let Ok((entity, mut pos, mut viewshed)) = query.get_single_mut() {
        // Blahblah, code you already wrote
    } else {
        RunState::AwaitingInput
    }
}

As you correctly intuited, the problem is that rust doesn't know you are borrowing different bits of ecs. The best API to work around that is to use SystemState, which has similar logic as system parameters.

[bbarker]

This is very helpful. It sounds like the recommendation may actually be to use one-shot systems to handle change detection and command flushing, instead of using SystemState directly. I may give that a try first.

[bbarker]

I ended up using @nicopap 's direct answer to come up with a somewhat different approach using one-shot systems:

pub fn try_move_player_system(
    In(dx_dy): In<(i32, i32)>,
    mut commands: Commands,
    mut log: ResMut<GameLog>,
    mut map: ResMut<Map>,
    mut query: Query<(Entity, &mut Position, &mut Viewshed), With<Player>>, // need mutable?
    combat_stats: Query<&CombatStats>,
) -> RunState {
    let (delta_x, delta_y) = dx_dy;
    // ...
    
}

pub fn try_move_player(ecs: &mut World, delta_x: i32, delta_y: i32) -> RunState {
    ecs.run_system_once_with((delta_x, delta_y), try_move_player_system)
}