xevion/Pac-Man
1
0
Fork 0
mirror of https://github.com/Xevion/Pac-Man.git synced 2025-12-15 14:12:29 -06:00
Code Issues Packages Projects Releases Wiki Activity

refactor: use Single<> for player queries

Browse Source
This commit is contained in:
Ryan Walters
2025-09-08 16:50:17 -05:00
parent 63e1059df8
commit c163171304
4 changed files with 66 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/systems/collision.rs
View File

@@ -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<StageTransition>,
mut score: ResMut<ScoreResource>,
mut game_state: ResMut<GameStage>,
pacman_query: Query<Entity, With<PlayerControlled>>,
player: Single<Entity, With<PlayerControlled>>,
ghost_query: Query<(Entity, &Ghost), With<GhostCollider>>,
mut ghost_state_query: Query<&mut GhostState>,
mut events: EventWriter<AudioEvent>,
@@ -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;

30
src/systems/player.rs
View File

@@ -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,32 +32,22 @@ pub fn player_control_system(
mut state: ResMut<GlobalState>,
mut debug_state: ResMut<DebugState>,
mut audio_state: ResMut<AudioState>,
mut players: Query<&mut BufferedDirection, (With<PlayerControlled>, Without<Frozen>)>,
mut errors: EventWriter<GameError>,
mut player: Option<Single<&mut BufferedDirection, (With<PlayerControlled>, Without<Frozen>)>>,
) {
// 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;
}
};
// 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");
*buffered_direction = BufferedDirection::Some {
***player_single = BufferedDirection::Some {
direction: *direction,
remaining_time: 0.25,
};
}
}
GameCommand::Exit => {
state.exit = true;
}
@@ -168,8 +157,8 @@ pub fn player_movement_system(
}
/// Applies tunnel slowdown based on the current node tile
pub fn player_tunnel_slowdown_system(map: Res<Map>, mut q: Query<(&Position, &mut MovementModifiers), With<PlayerControlled>>) {
if let Ok((position, mut modifiers)) = q.single_mut() {
pub fn player_tunnel_slowdown_system(map: Res<Map>, player: Single<(&Position, &mut MovementModifiers), With<PlayerControlled>>) {
let (position, mut modifiers) = player.into_inner();
let node = position.current_node();
let in_tunnel = map
.tile_at_node(node)
@@ -188,4 +177,3 @@ pub fn player_tunnel_slowdown_system(map: Res<Map>, mut q: Query<(&Position, &mu
modifiers.tunnel_slowdown_active = in_tunnel;
modifiers.speed_multiplier = if in_tunnel { 0.6 } else { 1.0 };
}
}

66
src/systems/state.rs
View File

@@ -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<AudioEvent>,
mut stage_event_reader: EventReader<StageTransition>,
mut blinking_query: Query<Entity, With<Blinking>>,
mut player_query: Query<(Entity, &mut Position), With<PlayerControlled>>,
player: Single<(Entity, &mut Position), With<PlayerControlled>>,
mut ghost_query: Query<(Entity, &Ghost, &mut Position), (With<GhostCollider>, Without<PlayerControlled>)>,
atlas: NonSendMut<SpriteAtlas>,
) {
@@ -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,23 +288,17 @@ 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() {
let (player_entity, mut pos) = player.into_inner();
*pos = Position::Stopped {
node: map.start_positions.pacman,
};
@@ -334,7 +313,6 @@ pub fn stage_system(
.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() {
@@ -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::<Hidden>();
for (entity, _, _) in ghost_query.iter_mut() {
commands.entity(entity).remove::<Hidden>();
}
}
(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::<Frozen>();
for (entity, _, _) in ghost_query.iter_mut() {
commands.entity(entity).remove::<Frozen>();
}
for entity in blinking_query.iter_mut() {
commands.entity(entity).remove::<Frozen>();
}
}

6
tests/player.rs
View File

@@ -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]