refactor(server): apply rustfmt and clippy suggestions

Formatting pass across simulation, perception, knowledge, NPC, and test modules. Includes two clippy fixes in monologue.rs (.values() instead of for (_, v) pattern). Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 00:40:43 +01:00
parent 8ec875385a
commit d0663c4193
21 changed files with 600 additions and 274 deletions
@@ -68,7 +68,12 @@ pub fn process_player_input(
    mut commands: Commands,
    registry: Res<EntityRegistry>,
    mut player_query: Query<
-        (Entity, &TilePosition, Option<&mut Stance>, Option<&mut PlayerMoveCooldown>),
+        (
+            Entity,
+            &TilePosition,
+            Option<&mut Stance>,
+            Option<&mut PlayerMoveCooldown>,
+        ),
        With<PlayerCharacter>,
    >,
    inventory_items: Query<(Entity, &CarriedBy, &ItemName, &InventorySlot)>,
@@ -143,34 +148,30 @@ pub fn process_player_input(
                time.tick_rate = rate;
                tracing::debug!("Tick rate set to {:?} by player input", rate);
            }
-            PlayerAction::Interact { target_entity_id, ref verb } => {
-                match verb.as_deref() {
-                    Some("Take") => {
-                        handle_take(
-                            &mut commands,
-                            &registry,
-                            &player_query,
-                            &inventory_items,
-                            target_entity_id,
-                        );
-                    }
-                    Some("Place") => {
-                        handle_place(
-                            &mut commands,
-                            &registry,
-                            &player_query,
-                            target_entity_id,
-                        );
-                    }
-                    _ => {
-                        tracing::info!(
+            PlayerAction::Interact {
+                target_entity_id,
+                ref verb,
+            } => match verb.as_deref() {
+                Some("Take") => {
+                    handle_take(
+                        &mut commands,
+                        &registry,
+                        &player_query,
+                        &inventory_items,
+                        target_entity_id,
+                    );
+                }
+                Some("Place") => {
+                    handle_place(&mut commands, &registry, &player_query, target_entity_id);
+                }
+                _ => {
+                    tracing::info!(
                            "Interact: target={:?}, verb={:?} — logged only, dialogue dispatch future scope (#415)",
                            target_entity_id,
                            verb,
                        );
-                    }
                }
-            }
+            },
            PlayerAction::UsePerceptionMode(ref mode) => {
                tracing::trace!("UsePerceptionMode({}) — no-op for Sprint 1", mode);
            }
@@ -192,7 +193,12 @@ pub fn process_player_input(
 #[allow(clippy::type_complexity)]
 fn apply_move(
    player_query: &mut Query<
-        (Entity, &TilePosition, Option<&mut Stance>, Option<&mut PlayerMoveCooldown>),
+        (
+            Entity,
+            &TilePosition,
+            Option<&mut Stance>,
+            Option<&mut PlayerMoveCooldown>,
+        ),
        With<PlayerCharacter>,
    >,
    commands: &mut Commands,
@@ -230,7 +236,12 @@ fn handle_take(
    commands: &mut Commands,
    registry: &EntityRegistry,
    player_query: &Query<
-        (Entity, &TilePosition, Option<&mut Stance>, Option<&mut PlayerMoveCooldown>),
+        (
+            Entity,
+            &TilePosition,
+            Option<&mut Stance>,
+            Option<&mut PlayerMoveCooldown>,
+        ),
        With<PlayerCharacter>,
    >,
    inventory_items: &Query<(Entity, &CarriedBy, &ItemName, &InventorySlot)>,
@@ -260,12 +271,16 @@ fn handle_take(
    // Check inventory capacity
    let occupied = occupied_slots_for(player_sid, inventory_items);
    let Some(slot) = find_next_slot(&occupied) else {
-        tracing::info!("Inventory full ({} slots), cannot take item", MAX_INVENTORY_SLOTS);
+        tracing::info!(
+            "Inventory full ({} slots), cannot take item",
+            MAX_INVENTORY_SLOTS
+        );
        return;
    };

    // Remove TilePosition (item leaves the ground), add CarriedBy + InventorySlot
-    commands.entity(target_entity)
+    commands
+        .entity(target_entity)
        .remove::<TilePosition>()
        .insert((CarriedBy(player_sid), InventorySlot(slot)));

@@ -284,7 +299,12 @@ fn handle_place(
    commands: &mut Commands,
    registry: &EntityRegistry,
    player_query: &Query<
-        (Entity, &TilePosition, Option<&mut Stance>, Option<&mut PlayerMoveCooldown>),
+        (
+            Entity,
+            &TilePosition,
+            Option<&mut Stance>,
+            Option<&mut PlayerMoveCooldown>,
+        ),
        With<PlayerCharacter>,
    >,
    target_entity_id: Option<u64>,
@@ -307,7 +327,8 @@ fn handle_place(
    let place_pos = *player_pos;

    // Remove inventory components, place item at player's tile
-    commands.entity(target_entity)
+    commands
+        .entity(target_entity)
        .remove::<CarriedBy>()
        .remove::<InventorySlot>()
        .insert(place_pos);
@@ -338,7 +359,10 @@ mod tests {
        });
        queue.push(PlayerInput {
            tick: 5,
-            action: PlayerAction::Interact { target_entity_id: None, verb: None },
+            action: PlayerAction::Interact {
+                target_entity_id: None,
+                verb: None,
+            },
        });
        let inputs = queue.drain_for_tick(3);
        assert_eq!(inputs.len(), 2);
@@ -406,7 +430,10 @@ mod tests {
        schedule.add_systems(process_player_input);
        schedule.run(&mut world);

-        assert_eq!(world.resource::<SimulationTime>().tick_rate, TickRate::Paused);
+        assert_eq!(
+            world.resource::<SimulationTime>().tick_rate,
+            TickRate::Paused
+        );
    }

    #[test]
@@ -553,7 +580,10 @@ mod tests {
            action: PlayerAction::MoveNorth,
        });
        schedule.run(&mut world);
-        assert!(world.get::<MoveIntent>(player).is_some(), "first move should succeed");
+        assert!(
+            world.get::<MoveIntent>(player).is_some(),
+            "first move should succeed"
+        );

        // Remove MoveIntent (simulating validate_movement consuming it)
        world.entity_mut(player).remove::<MoveIntent>();
@@ -564,7 +594,10 @@ mod tests {
            action: PlayerAction::MoveNorth,
        });
        schedule.run(&mut world);
-        assert!(world.get::<MoveIntent>(player).is_none(), "second move should be throttled");
+        assert!(
+            world.get::<MoveIntent>(player).is_none(),
+            "second move should be throttled"
+        );

        // Tick 0 again: move north — should succeed (cooldown elapsed)
        world.resource_mut::<InputQueue>().push(PlayerInput {
@@ -572,7 +605,10 @@ mod tests {
            action: PlayerAction::MoveNorth,
        });
        schedule.run(&mut world);
-        assert!(world.get::<MoveIntent>(player).is_some(), "third move should succeed after cooldown");
+        assert!(
+            world.get::<MoveIntent>(player).is_some(),
+            "third move should succeed after cooldown"
+        );
    }

    #[test]
@@ -609,7 +645,10 @@ mod tests {
            action: PlayerAction::MoveNorth,
        });
        schedule.run(&mut world);
-        assert!(world.get::<MoveIntent>(player).is_some(), "sprint should allow every tick");
+        assert!(
+            world.get::<MoveIntent>(player).is_some(),
+            "sprint should allow every tick"
+        );
    }

    #[test]
@@ -655,16 +694,17 @@ mod tests {
        let player = world
            .spawn((PlayerCharacter, TilePosition::new(5, 5, 0)))
            .id();
-        let player_sid = world.resource_mut::<crate::knowledge::EntityRegistry>().register(player);
+        let player_sid = world
+            .resource_mut::<crate::knowledge::EntityRegistry>()
+            .register(player);

        // Spawn item near player
        let item = world
-            .spawn((
-                TilePosition::new(5, 4, 0),
-                ItemName("Manifest Copy".into()),
-            ))
+            .spawn((TilePosition::new(5, 4, 0), ItemName("Manifest Copy".into())))
            .id();
-        let item_sid = world.resource_mut::<crate::knowledge::EntityRegistry>().register(item);
+        let item_sid = world
+            .resource_mut::<crate::knowledge::EntityRegistry>()
+            .register(item);

        // Issue Take verb
        world.resource_mut::<InputQueue>().push(PlayerInput {
@@ -680,10 +720,17 @@ mod tests {
        schedule.run(&mut world);

        // Item should have CarriedBy + InventorySlot, no TilePosition
-        assert!(world.get::<TilePosition>(item).is_none(), "item should leave the ground");
-        let carried = world.get::<CarriedBy>(item).expect("item should have CarriedBy");
+        assert!(
+            world.get::<TilePosition>(item).is_none(),
+            "item should leave the ground"
+        );
+        let carried = world
+            .get::<CarriedBy>(item)
+            .expect("item should have CarriedBy");
        assert_eq!(carried.0, player_sid);
-        let slot = world.get::<InventorySlot>(item).expect("item should have slot");
+        let slot = world
+            .get::<InventorySlot>(item)
+            .expect("item should have slot");
        assert_eq!(slot.0, 0, "first item goes to slot 0");
    }

@@ -697,7 +744,9 @@ mod tests {
        let player = world
            .spawn((PlayerCharacter, TilePosition::new(5, 5, 0)))
            .id();
-        let player_sid = world.resource_mut::<crate::knowledge::EntityRegistry>().register(player);
+        let player_sid = world
+            .resource_mut::<crate::knowledge::EntityRegistry>()
+            .register(player);

        // Spawn item already in inventory (no TilePosition)
        let item = world
@@ -707,7 +756,9 @@ mod tests {
                InventorySlot(0),
            ))
            .id();
-        let item_sid = world.resource_mut::<crate::knowledge::EntityRegistry>().register(item);
+        let item_sid = world
+            .resource_mut::<crate::knowledge::EntityRegistry>()
+            .register(item);

        // Issue Place verb
        world.resource_mut::<InputQueue>().push(PlayerInput {
@@ -723,10 +774,19 @@ mod tests {
        schedule.run(&mut world);

        // Item should have TilePosition at player's location, no CarriedBy/InventorySlot
-        let pos = world.get::<TilePosition>(item).expect("item should be on ground");
-        assert_eq!(*pos, TilePosition::new(5, 5, 0), "placed at player position");
+        let pos = world
+            .get::<TilePosition>(item)
+            .expect("item should be on ground");
+        assert_eq!(
+            *pos,
+            TilePosition::new(5, 5, 0),
+            "placed at player position"
+        );
        assert!(world.get::<CarriedBy>(item).is_none(), "CarriedBy removed");
-        assert!(world.get::<InventorySlot>(item).is_none(), "InventorySlot removed");
+        assert!(
+            world.get::<InventorySlot>(item).is_none(),
+            "InventorySlot removed"
+        );
    }

    #[test]
@@ -739,7 +799,9 @@ mod tests {
        let player = world
            .spawn((PlayerCharacter, TilePosition::new(5, 5, 0)))
            .id();
-        let player_sid = world.resource_mut::<crate::knowledge::EntityRegistry>().register(player);
+        let player_sid = world
+            .resource_mut::<crate::knowledge::EntityRegistry>()
+            .register(player);

        // Item already in slot 0
        world.spawn((
@@ -750,12 +812,11 @@ mod tests {

        // New item on the ground
        let item2 = world
-            .spawn((
-                TilePosition::new(5, 4, 0),
-                ItemName("Token".into()),
-            ))
+            .spawn((TilePosition::new(5, 4, 0), ItemName("Token".into())))
            .id();
-        let item2_sid = world.resource_mut::<crate::knowledge::EntityRegistry>().register(item2);
+        let item2_sid = world
+            .resource_mut::<crate::knowledge::EntityRegistry>()
+            .register(item2);

        world.resource_mut::<InputQueue>().push(PlayerInput {
            tick: 0,
@@ -769,7 +830,9 @@ mod tests {
        schedule.add_systems(process_player_input);
        schedule.run(&mut world);

-        let slot = world.get::<InventorySlot>(item2).expect("item should have slot");
+        let slot = world
+            .get::<InventorySlot>(item2)
+            .expect("item should have slot");
        assert_eq!(slot.0, 1, "second item goes to slot 1");
    }

@@ -783,7 +846,9 @@ mod tests {
        let player = world
            .spawn((PlayerCharacter, TilePosition::new(5, 5, 0)))
            .id();
-        let player_sid = world.resource_mut::<crate::knowledge::EntityRegistry>().register(player);
+        let player_sid = world
+            .resource_mut::<crate::knowledge::EntityRegistry>()
+            .register(player);

        // Fill all 9 slots
        for slot in 0..MAX_INVENTORY_SLOTS {
@@ -796,12 +861,11 @@ mod tests {

        // Try to take another item
        let item = world
-            .spawn((
-                TilePosition::new(5, 4, 0),
-                ItemName("Overflow".into()),
-            ))
+            .spawn((TilePosition::new(5, 4, 0), ItemName("Overflow".into())))
            .id();
-        let item_sid = world.resource_mut::<crate::knowledge::EntityRegistry>().register(item);
+        let item_sid = world
+            .resource_mut::<crate::knowledge::EntityRegistry>()
+            .register(item);

        world.resource_mut::<InputQueue>().push(PlayerInput {
            tick: 0,
@@ -816,8 +880,14 @@ mod tests {
        schedule.run(&mut world);

        // Item should still be on the ground
-        assert!(world.get::<TilePosition>(item).is_some(), "item stays on ground");
-        assert!(world.get::<CarriedBy>(item).is_none(), "no CarriedBy when full");
+        assert!(
+            world.get::<TilePosition>(item).is_some(),
+            "item stays on ground"
+        );
+        assert!(
+            world.get::<CarriedBy>(item).is_none(),
+            "no CarriedBy when full"
+        );
    }

    #[test]
@@ -831,15 +901,16 @@ mod tests {
        let player = world
            .spawn((PlayerCharacter, TilePosition::new(5, 5, 0)))
            .id();
-        let player_sid = world.resource_mut::<crate::knowledge::EntityRegistry>().register(player);
+        let player_sid = world
+            .resource_mut::<crate::knowledge::EntityRegistry>()
+            .register(player);

        let item = world
-            .spawn((
-                TilePosition::new(5, 4, 0),
-                ItemName("Manifest Copy".into()),
-            ))
+            .spawn((TilePosition::new(5, 4, 0), ItemName("Manifest Copy".into())))
            .id();
-        let item_sid = world.resource_mut::<crate::knowledge::EntityRegistry>().register(item);
+        let item_sid = world
+            .resource_mut::<crate::knowledge::EntityRegistry>()
+            .register(item);

        let mut schedule = bevy_ecs::schedule::Schedule::default();
        schedule.add_systems(process_player_input);
@@ -854,7 +925,10 @@ mod tests {
        });
        schedule.run(&mut world);

-        assert!(world.get::<TilePosition>(item).is_none(), "item off ground after Take");
+        assert!(
+            world.get::<TilePosition>(item).is_none(),
+            "item off ground after Take"
+        );
        assert_eq!(world.get::<CarriedBy>(item).unwrap().0, player_sid);
        assert_eq!(world.get::<InventorySlot>(item).unwrap().0, 0);

@@ -869,10 +943,22 @@ mod tests {
        world.resource_mut::<SimulationTime>().tick = 1;
        schedule.run(&mut world);

-        let pos = world.get::<TilePosition>(item).expect("item back on ground after Place");
-        assert_eq!(*pos, TilePosition::new(5, 5, 0), "placed at player position");
-        assert!(world.get::<CarriedBy>(item).is_none(), "CarriedBy removed after Place");
-        assert!(world.get::<InventorySlot>(item).is_none(), "InventorySlot removed after Place");
+        let pos = world
+            .get::<TilePosition>(item)
+            .expect("item back on ground after Place");
+        assert_eq!(
+            *pos,
+            TilePosition::new(5, 5, 0),
+            "placed at player position"
+        );
+        assert!(
+            world.get::<CarriedBy>(item).is_none(),
+            "CarriedBy removed after Place"
+        );
+        assert!(
+            world.get::<InventorySlot>(item).is_none(),
+            "InventorySlot removed after Place"
+        );
    }

    #[test]