diff --git a/src/systems/collision.rs b/src/systems/collision.rs index ceee8ef..a39cab4 100644 --- a/src/systems/collision.rs +++ b/src/systems/collision.rs @@ -3,7 +3,7 @@ use bevy_ecs::{ entity::Entity, event::{EventReader, EventWriter}, query::With, - system::{Commands, Query, Res, ResMut}, + system::{Commands, Query, Res, ResMut, Single}, }; use tracing::{debug, trace, warn}; @@ -123,7 +123,7 @@ pub fn ghost_collision_system( mut stage_events: EventWriter, mut score: ResMut, mut game_state: ResMut, - pacman_query: Query>, + player: Single>, ghost_query: Query<(Entity, &Ghost), With>, mut ghost_state_query: Query<&mut GhostState>, mut events: EventWriter, @@ -131,9 +131,9 @@ pub fn ghost_collision_system( for event in collision_events.read() { if let GameEvent::Collision(entity1, entity2) = event { // Check if one is Pacman and the other is a ghost - let (pacman_entity, ghost_entity) = if pacman_query.get(*entity1).is_ok() && ghost_query.get(*entity2).is_ok() { + let (pacman_entity, ghost_entity) = if *entity1 == *player && ghost_query.get(*entity2).is_ok() { (*entity1, *entity2) - } else if pacman_query.get(*entity2).is_ok() && ghost_query.get(*entity1).is_ok() { + } else if *entity2 == *player && ghost_query.get(*entity1).is_ok() { (*entity2, *entity1) } else { continue; diff --git a/src/systems/player.rs b/src/systems/player.rs index 8973fdf..cfb32cf 100644 --- a/src/systems/player.rs +++ b/src/systems/player.rs @@ -1,12 +1,11 @@ use bevy_ecs::{ - event::{EventReader, EventWriter}, + event::EventReader, query::{With, Without}, - system::{Query, Res, ResMut}, + system::{Query, Res, ResMut, Single}, }; use tracing::trace; use crate::{ - error::GameError, events::{GameCommand, GameEvent}, map::{builder::Map, graph::Edge}, systems::{ @@ -33,31 +32,21 @@ pub fn player_control_system( mut state: ResMut, mut debug_state: ResMut, mut audio_state: ResMut, - mut players: Query<&mut BufferedDirection, (With, Without)>, - mut errors: EventWriter, + mut player: Option, Without)>>, ) { // Handle events for event in events.read() { if let GameEvent::Command(command) = event { match command { GameCommand::MovePlayer(direction) => { - // Get the player's movable component (ensuring there is only one player) - let mut buffered_direction = match players.single_mut() { - Ok(tuple) => tuple, - Err(e) => { - errors.write(GameError::InvalidState(format!( - "No/multiple entities queried for player system: {}", - e - ))); - return; - } - }; - - trace!(direction = ?*direction, "Player direction buffered for movement"); - *buffered_direction = BufferedDirection::Some { - direction: *direction, - remaining_time: 0.25, - }; + // Only handle movement if there's an unfrozen player + if let Some(player_single) = player.as_mut() { + trace!(direction = ?*direction, "Player direction buffered for movement"); + ***player_single = BufferedDirection::Some { + direction: *direction, + remaining_time: 0.25, + }; + } } GameCommand::Exit => { state.exit = true; @@ -168,24 +157,23 @@ pub fn player_movement_system( } /// Applies tunnel slowdown based on the current node tile -pub fn player_tunnel_slowdown_system(map: Res, mut q: Query<(&Position, &mut MovementModifiers), With>) { - if let Ok((position, mut modifiers)) = q.single_mut() { - let node = position.current_node(); - let in_tunnel = map - .tile_at_node(node) - .map(|t| t == crate::constants::MapTile::Tunnel) - .unwrap_or(false); +pub fn player_tunnel_slowdown_system(map: Res, player: Single<(&Position, &mut MovementModifiers), With>) { + let (position, mut modifiers) = player.into_inner(); + let node = position.current_node(); + let in_tunnel = map + .tile_at_node(node) + .map(|t| t == crate::constants::MapTile::Tunnel) + .unwrap_or(false); - if modifiers.tunnel_slowdown_active != in_tunnel { - trace!( - node, - in_tunnel, - speed_multiplier = if in_tunnel { 0.6 } else { 1.0 }, - "Player tunnel slowdown state changed" - ); - } - - modifiers.tunnel_slowdown_active = in_tunnel; - modifiers.speed_multiplier = if in_tunnel { 0.6 } else { 1.0 }; + if modifiers.tunnel_slowdown_active != in_tunnel { + trace!( + node, + in_tunnel, + speed_multiplier = if in_tunnel { 0.6 } else { 1.0 }, + "Player tunnel slowdown state changed" + ); } + + modifiers.tunnel_slowdown_active = in_tunnel; + modifiers.speed_multiplier = if in_tunnel { 0.6 } else { 1.0 }; } diff --git a/src/systems/state.rs b/src/systems/state.rs index b6e5a23..8dfd848 100644 --- a/src/systems/state.rs +++ b/src/systems/state.rs @@ -15,7 +15,7 @@ use bevy_ecs::{ event::{EventReader, EventWriter}, query::{With, Without}, resource::Resource, - system::{Commands, NonSendMut, Query, Res, ResMut}, + system::{Commands, NonSendMut, Query, Res, ResMut, Single}, }; #[derive(Resource, Clone)] @@ -122,7 +122,7 @@ pub fn stage_system( mut audio_events: EventWriter, mut stage_event_reader: EventReader, mut blinking_query: Query>, - mut player_query: Query<(Entity, &mut Position), With>, + player: Single<(Entity, &mut Position), With>, mut ghost_query: Query<(Entity, &Ghost, &mut Position), (With, Without)>, atlas: NonSendMut, ) { @@ -132,11 +132,7 @@ pub fn stage_system( // Handle stage transition requests before normal ticking for event in stage_event_reader.read() { let StageTransition::GhostEatenPause { ghost_entity } = *event; - let pac_node = player_query - .single_mut() - .ok() - .map(|(_, pos)| pos.current_node()) - .unwrap_or(map.start_positions.pacman); + let pac_node = player.1.current_node(); debug!(ghost_entity = ?ghost_entity, node = pac_node, "Ghost eaten, entering pause state"); new_state = Some(GameStage::GhostEatenPause { @@ -240,18 +236,13 @@ pub fn stage_system( match (old_state, new_state) { (GameStage::Playing, GameStage::GhostEatenPause { ghost_entity, node, .. }) => { // Freeze the player & ghosts - for entity in player_query - .iter_mut() - .map(|(e, _)| e) - .chain(ghost_query.iter_mut().map(|(e, _, _)| e)) - { + commands.entity(player.0).insert(Frozen); + for (entity, _, _) in ghost_query.iter_mut() { commands.entity(entity).insert(Frozen); } // Hide the player & eaten ghost - for (player_entity, _) in player_query.iter_mut() { - commands.entity(player_entity).insert(Hidden); - } + commands.entity(player.0).insert(Hidden); commands.entity(ghost_entity).insert(Hidden); // Spawn bonus points entity at Pac-Man's position @@ -275,11 +266,8 @@ pub fn stage_system( } (GameStage::GhostEatenPause { ghost_entity, .. }, GameStage::Playing) => { // Unfreeze and reveal the player & all ghosts - for entity in player_query - .iter_mut() - .map(|(e, _)| e) - .chain(ghost_query.iter_mut().map(|(e, _, _)| e)) - { + commands.entity(player.0).remove::<(Frozen, Hidden)>(); + for (entity, _, _) in ghost_query.iter_mut() { commands.entity(entity).remove::<(Frozen, Hidden)>(); } @@ -288,11 +276,8 @@ pub fn stage_system( } (GameStage::Playing, GameStage::PlayerDying(DyingSequence::Frozen { .. })) => { // Freeze the player & ghosts - for entity in player_query - .iter_mut() - .map(|(e, _)| e) - .chain(ghost_query.iter_mut().map(|(e, _, _)| e)) - { + commands.entity(player.0).insert(Frozen); + for (entity, _, _) in ghost_query.iter_mut() { commands.entity(entity).insert(Frozen); } } @@ -303,39 +288,32 @@ pub fn stage_system( } // Start Pac-Man's death animation - if let Ok((player_entity, _)) = player_query.single_mut() { - commands - .entity(player_entity) - .insert((Dying, player_death_animation.0.clone())); - } + commands.entity(player.0).insert((Dying, player_death_animation.0.clone())); // Play the death sound audio_events.write(AudioEvent::PlayDeath); } (GameStage::PlayerDying(DyingSequence::Animating { .. }), GameStage::PlayerDying(DyingSequence::Hidden { .. })) => { // Hide the player - if let Ok((player_entity, _)) = player_query.single_mut() { - commands.entity(player_entity).insert(Hidden); - } + commands.entity(player.0).insert(Hidden); } (_, GameStage::LevelRestarting) => { - if let Ok((player_entity, mut pos)) = player_query.single_mut() { - *pos = Position::Stopped { - node: map.start_positions.pacman, - }; + let (player_entity, mut pos) = player.into_inner(); + *pos = Position::Stopped { + node: map.start_positions.pacman, + }; - // Freeze the blinking, force them to be visible (if they were hidden by blinking) - for entity in blinking_query.iter_mut() { - commands.entity(entity).insert(Frozen).remove::(); - } - - // Reset the player animation - commands - .entity(player_entity) - .remove::<(Frozen, Dying, LinearAnimation, Looping)>() - .insert(player_animation.0.clone()); + // Freeze the blinking, force them to be visible (if they were hidden by blinking) + for entity in blinking_query.iter_mut() { + commands.entity(entity).insert(Frozen).remove::(); } + // Reset the player animation + commands + .entity(player_entity) + .remove::<(Frozen, Dying, LinearAnimation, Looping)>() + .insert(player_animation.0.clone()); + // Reset ghost positions and state for (ghost_entity, ghost, mut ghost_pos) in ghost_query.iter_mut() { *ghost_pos = Position::Stopped { @@ -354,22 +332,18 @@ pub fn stage_system( } (_, GameStage::Starting(StartupSequence::CharactersVisible { .. })) => { // Unhide the player & ghosts - for entity in player_query - .iter_mut() - .map(|(e, _)| e) - .chain(ghost_query.iter_mut().map(|(e, _, _)| e)) - { + commands.entity(player.0).remove::(); + for (entity, _, _) in ghost_query.iter_mut() { commands.entity(entity).remove::(); } } (GameStage::Starting(StartupSequence::CharactersVisible { .. }), GameStage::Playing) => { // Unfreeze the player & ghosts & blinking - for entity in player_query - .iter_mut() - .map(|(e, _)| e) - .chain(ghost_query.iter_mut().map(|(e, _, _)| e)) - .chain(blinking_query.iter_mut()) - { + commands.entity(player.0).remove::(); + for (entity, _, _) in ghost_query.iter_mut() { + commands.entity(entity).remove::(); + } + for entity in blinking_query.iter_mut() { commands.entity(entity).remove::(); } } diff --git a/tests/player.rs b/tests/player.rs index 5ac7dc0..0a5272f 100644 --- a/tests/player.rs +++ b/tests/player.rs @@ -214,11 +214,9 @@ fn test_player_control_system_no_player_entity() { // Run the system - should write an error world .run_system_once(player_control_system) - .expect("System should run successfully"); + .expect("System should run successfully even with no player entity"); - // Check that an error was written (we can't easily check Events without manual management, - // so for this test we just verify the system ran without panicking) - // In a real implementation, you might expose error checking through the ECS world + // The system should run successfully and simply ignore movement commands when there's no player } #[test]