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

refactor: unify ghost state management and animation handling, use integers for texture animation

Browse Source
This commit is contained in:
Ryan Walters
2025-09-01 14:27:48 -05:00
parent e1a2e6ab62
commit b53db3788d
13 changed files with 221 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
src/systems/collision.rs
View File

@@ -2,13 +2,13 @@ use bevy_ecs::component::Component;
use bevy_ecs::entity::Entity;
use bevy_ecs::event::{EventReader, EventWriter};
use bevy_ecs::query::With;
use bevy_ecs::system::{Commands, Query, Res, ResMut};
use bevy_ecs::system::{Query, Res, ResMut};
use crate::error::GameError;
use crate::events::GameEvent;
use crate::map::builder::Map;
use crate::systems::movement::Position;
use crate::systems::{AudioEvent, Eaten, Ghost, PlayerControlled, ScoreResource, Vulnerable};
use crate::systems::{AudioEvent, Ghost, GhostState, PlayerControlled, ScoreResource};
#[derive(Component)]
pub struct Collider {
@@ -108,12 +108,11 @@ pub fn collision_system(
}
pub fn ghost_collision_system(
mut commands: Commands,
mut collision_events: EventReader<GameEvent>,
mut score: ResMut<ScoreResource>,
pacman_query: Query<(), With<PlayerControlled>>,
ghost_query: Query<(Entity, &Ghost), With<GhostCollider>>,
vulnerable_query: Query<Entity, With<Vulnerable>>,
mut ghost_state_query: Query<&mut GhostState>,
mut events: EventWriter<AudioEvent>,
) {
for event in collision_events.read() {
@@ -127,23 +126,25 @@ pub fn ghost_collision_system(
continue;
};
// Check if the ghost is vulnerable
// Check if the ghost is frightened
if let Ok((ghost_ent, _ghost_type)) = ghost_query.get(ghost_entity) {
// Check if ghost has Vulnerable component
if vulnerable_query.get(ghost_ent).is_ok() {
// Pac-Man eats the ghost
// Add score (200 points per ghost eaten)
score.0 += 200;
if let Ok(mut ghost_state) = ghost_state_query.get_mut(ghost_ent) {
// Check if ghost is in frightened state
if matches!(*ghost_state, GhostState::Frightened { .. }) {
// Pac-Man eats the ghost
// Add score (200 points per ghost eaten)
score.0 += 200;
// Remove the ghost
commands.entity(ghost_ent).remove::<Vulnerable>().insert(Eaten);
// Set ghost state to Eyes
*ghost_state = GhostState::Eyes;
// Play eat sound
events.write(AudioEvent::PlayEat);
} else {
// Pac-Man dies (this would need a death system)
// For now, just log it
tracing::warn!("Pac-Man collided with ghost while not vulnerable!");
// Play eat sound
events.write(AudioEvent::PlayEat);
} else {
// Pac-Man dies (this would need a death system)
// For now, just log it
tracing::warn!("Pac-Man collided with ghost while not frightened!");
}
}
}
}

109
src/systems/components.rs
View File

@@ -1,5 +1,6 @@
use bevy_ecs::{bundle::Bundle, component::Component, resource::Resource};
use bitflags::bitflags;
use tracing::debug;
use crate::{
map::graph::TraversalFlags,
@@ -122,6 +123,20 @@ impl DirectionalAnimated {
],
}
}
/// Resets all directional animations to frame 0 for synchronization
pub fn reset_all_animations(&mut self) {
for texture in &mut self.textures {
if let Some(anim) = texture {
anim.reset();
}
}
for texture in &mut self.stopped_textures {
if let Some(anim) = texture {
anim.reset();
}
}
}
}
bitflags! {
@@ -170,10 +185,82 @@ pub struct Frozen;
#[derive(Component, Debug, Clone, Copy)]
pub struct Eaten;
/// Component for ghosts that are vulnerable to Pac-Man
#[derive(Component, Debug, Clone, Copy)]
pub struct Vulnerable {
pub remaining_ticks: u32,
pub enum GhostState {
/// Normal ghost behavior - chasing Pac-Man
Normal,
/// Frightened state after power pellet - ghost can be eaten
Frightened {
remaining_ticks: u32,
flash: bool,
remaining_flash_ticks: u32,
},
/// Eyes state - ghost has been eaten and is returning to ghost house
Eyes,
}
/// Component to track the last animation state for efficient change detection
#[derive(Component, Debug, Clone, Copy, PartialEq)]
pub struct LastAnimationState(pub GhostAnimation);
impl GhostState {
/// Creates a new frightened state with the specified duration
pub fn new_frightened(total_ticks: u32, flash_start_ticks: u32) -> Self {
Self::Frightened {
remaining_ticks: total_ticks,
flash: false,
remaining_flash_ticks: flash_start_ticks, // Time until flashing starts
}
}
/// Ticks the ghost state, returning true if the state changed.
pub fn tick(&mut self) -> bool {
match self {
GhostState::Frightened { .. } => {
debug!("{:?}", self);
}
_ => {}
}
if let GhostState::Frightened {
remaining_ticks,
flash,
remaining_flash_ticks,
} = self
{
// Transition out of frightened state
if *remaining_ticks == 0 {
*self = GhostState::Normal;
return true;
}
*remaining_ticks -= 1;
if *remaining_flash_ticks > 0 {
*remaining_flash_ticks = remaining_flash_ticks.saturating_sub(1);
if *remaining_flash_ticks == 0 {
*flash = true;
true
} else {
false
}
} else {
false
}
} else {
false
}
}
/// Returns the appropriate animation state for this ghost state
pub fn animation_state(&self) -> GhostAnimation {
match self {
GhostState::Normal => GhostAnimation::Normal,
GhostState::Eyes => GhostAnimation::Eyes,
GhostState::Frightened { flash: false, .. } => GhostAnimation::Frightened { flash: false },
GhostState::Frightened { flash: true, .. } => GhostAnimation::Frightened { flash: true },
}
}
}
/// Enumeration of different ghost animation states.
@@ -190,10 +277,6 @@ pub enum GhostAnimation {
}
/// A complete set of animations for a ghost in different behavioral states.
///
/// Each ghost maintains animations mapped by their current gameplay state.
/// The animation system automatically switches between these states based on
/// the presence of `Vulnerable` and `Eaten` components on the ghost entity.
#[derive(Component, Clone)]
pub struct GhostAnimationSet {
pub animations: Map<GhostAnimation, DirectionalAnimated, 4>,
@@ -225,16 +308,6 @@ impl GhostAnimationSet {
self.get(GhostAnimation::Normal)
}
/// Gets the frightened animation state (non-flashing).
pub fn frightened(&self) -> Option<&DirectionalAnimated> {
self.get(GhostAnimation::Frightened { flash: false })
}
/// Gets the frightened flashing animation state.
pub fn frightened_flashing(&self) -> Option<&DirectionalAnimated> {
self.get(GhostAnimation::Frightened { flash: true })
}
/// Gets the eyes animation state (for eaten ghosts).
pub fn eyes(&self) -> Option<&DirectionalAnimated> {
self.get(GhostAnimation::Eyes)
@@ -285,4 +358,6 @@ pub struct GhostBundle {
pub entity_type: EntityType,
pub collider: Collider,
pub ghost_collider: GhostCollider,
pub ghost_state: GhostState,
pub last_animation_state: LastAnimationState,
}

113
src/systems/ghost.rs
View File

@@ -1,4 +1,4 @@
use crate::systems::components::Frozen;
use crate::systems::components::{DirectionalAnimated, Frozen, GhostState, LastAnimationState};
use crate::{
map::{
builder::Map,
@@ -11,15 +11,9 @@ use crate::{
},
};
use bevy_ecs::{
query::Added,
removal_detection::RemovedComponents,
system::{Commands, Query, Res},
};
use crate::systems::{Eaten, GhostAnimations, Vulnerable};
use bevy_ecs::query::{With, Without};
use crate::systems::GhostAnimations;
use bevy_ecs::query::Without;
use bevy_ecs::system::{Query, Res};
use rand::rngs::SmallRng;
use rand::seq::IndexedRandom;
use rand::SeedableRng;
@@ -77,64 +71,6 @@ pub fn ghost_movement_system(
}
}
/// System that manages ghost animation state transitions based on ghost behavior.
///
/// This system handles the following animation state changes:
/// - When a ghost becomes vulnerable (power pellet eaten): switches to frightened animation
/// - When a ghost is eaten by Pac-Man: switches to eaten (eyes) animation
/// - When vulnerability ends: switches back to normal animation
///
/// The system uses ECS change detection to efficiently track state transitions:
/// - `Added<Vulnerable>` detects when ghosts become frightened
/// - `Added<Eaten>` detects when ghosts are consumed
/// - `RemovedComponents<Vulnerable>` detects when fright period ends
///
/// This ensures smooth visual feedback for gameplay state changes while maintaining
/// separation between game logic and animation state.
pub fn ghost_state_animation_system(
mut commands: Commands,
animations: Res<GhostAnimations>,
mut vulnerable_added: Query<(bevy_ecs::entity::Entity, &Ghost), Added<Vulnerable>>,
mut eaten_added: Query<(bevy_ecs::entity::Entity, &Ghost), Added<Eaten>>,
mut vulnerable_removed: RemovedComponents<Vulnerable>,
ghosts: Query<&Ghost>,
eaten_ghosts: Query<&Ghost, With<Eaten>>,
) {
// When a ghost becomes vulnerable, switch to the frightened animation
for (entity, ghost_type) in vulnerable_added.iter_mut() {
if let Some(animation_set) = animations.0.get(ghost_type) {
if let Some(animation) = animation_set.frightened() {
commands.entity(entity).insert(animation.clone());
}
}
}
// When a ghost is eaten, switch to the eaten animation
for (entity, ghost_type) in eaten_added.iter_mut() {
if let Some(animation_set) = animations.0.get(ghost_type) {
if let Some(animation) = animation_set.eyes() {
commands.entity(entity).insert(animation.clone());
}
}
}
// When a ghost is no longer vulnerable, switch back to the normal animation
// But don't switch if the ghost is currently eaten (should keep eyes animation)
for entity in vulnerable_removed.read() {
if let Ok(ghost_type) = ghosts.get(entity) {
// Check if this ghost is currently eaten - if so, don't switch to normal animation
let is_eaten = eaten_ghosts.get(entity).is_ok();
if !is_eaten {
if let Some(animation_set) = animations.0.get(ghost_type) {
if let Some(animation) = animation_set.normal() {
commands.entity(entity).insert(animation.clone());
}
}
}
}
}
}
/// System that handles eaten ghost behavior and respawn logic.
///
/// When a ghost is eaten by Pac-Man, it enters an "eaten" state where:
@@ -146,11 +82,13 @@ pub fn ghost_state_animation_system(
pub fn eaten_ghost_system(
map: Res<Map>,
delta_time: Res<DeltaTime>,
animations: Res<GhostAnimations>,
mut commands: Commands,
mut eaten_ghosts: Query<(bevy_ecs::entity::Entity, &Ghost, &mut Position, &mut Velocity), With<Eaten>>,
mut eaten_ghosts: Query<(&Ghost, &mut Position, &mut Velocity, &mut GhostState)>,
) {
for (entity, ghost_type, mut position, mut velocity) in eaten_ghosts.iter_mut() {
for (ghost_type, mut position, mut velocity, mut ghost_state) in eaten_ghosts.iter_mut() {
// Only process ghosts that are in Eyes state
if !matches!(*ghost_state, GhostState::Eyes) {
continue;
}
// Set higher speed for eaten ghosts returning to ghost house
let original_speed = velocity.speed;
velocity.speed = ghost_type.base_speed() * 2.0; // Move twice as fast when eaten
@@ -178,13 +116,8 @@ pub fn eaten_ghost_system(
if let Some(_overflow) = position.tick(distance) {
// Reached target node, check if we're at ghost house center
if to == ghost_house_center {
// Respawn the ghost - remove Eaten component and switch to normal animation
commands.entity(entity).remove::<Eaten>();
if let Some(animation_set) = animations.0.get(ghost_type) {
if let Some(animation) = animation_set.normal() {
commands.entity(entity).insert(animation.clone());
}
}
// Respawn the ghost - set state back to normal
*ghost_state = GhostState::Normal;
// Reset to stopped at ghost house center
*position = Position::Stopped {
node: ghost_house_center,
@@ -246,3 +179,25 @@ fn find_direction_to_target(
None
}
/// Unified system that manages ghost state transitions and animations
pub fn ghost_state_system(
animations: Res<GhostAnimations>,
mut ghosts: Query<(&Ghost, &mut GhostState, &mut DirectionalAnimated, &mut LastAnimationState)>,
) {
for (ghost_type, mut ghost_state, mut directional_animated, mut last_animation_state) in ghosts.iter_mut() {
// Tick the ghost state to handle internal transitions (like flashing)
let _ = ghost_state.tick();
// Only update animation if the animation state actually changed
let current_animation_state = ghost_state.animation_state();
if last_animation_state.0 != current_animation_state {
let animation_set = animations.0.get(ghost_type).unwrap();
let animation = animation_set.get(current_animation_state).unwrap();
*directional_animated = (*animation).clone();
// Reset animation timers to synchronize all ghosts
directional_animated.reset_all_animations();
last_animation_state.0 = current_animation_state;
}
}
}

16
src/systems/item.rs
View File

@@ -6,8 +6,9 @@ use bevy_ecs::{
};
use crate::{
constants::animation::FRIGHTENED_FLASH_START_TICKS,
events::GameEvent,
systems::{AudioEvent, EntityType, GhostCollider, ItemCollider, PacmanCollider, ScoreResource, Vulnerable},
systems::{AudioEvent, EntityType, GhostCollider, GhostState, ItemCollider, PacmanCollider, ScoreResource},
};
/// Determines if a collision between two entity types should be handled by the item system.
@@ -28,6 +29,7 @@ pub fn item_system(
pacman_query: Query<Entity, With<PacmanCollider>>,
item_query: Query<(Entity, &EntityType), With<ItemCollider>>,
ghost_query: Query<Entity, With<GhostCollider>>,
mut ghost_state_query: Query<&mut GhostState>,
mut events: EventWriter<AudioEvent>,
) {
for event in collision_events.read() {
@@ -54,16 +56,16 @@ pub fn item_system(
events.write(AudioEvent::PlayEat);
}
// Make ghosts vulnerable when power pellet is collected
// Make ghosts frightened when power pellet is collected
if *entity_type == EntityType::PowerPellet {
// Convert seconds to frames (assumes 60 FPS)
let total_ticks = 60 * 5;
let total_ticks = 60 * 5; // 5 seconds total
// Add Vulnerable component to all ghosts
// Set all ghosts to frightened state
for ghost_entity in ghost_query.iter() {
commands.entity(ghost_entity).insert(Vulnerable {
remaining_ticks: total_ticks,
});
if let Ok(mut ghost_state) = ghost_state_query.get_mut(ghost_entity) {
*ghost_state = GhostState::new_frightened(total_ticks, FRIGHTENED_FLASH_START_TICKS);
}
}
}
}

2
src/systems/mod.rs
View File

@@ -16,7 +16,6 @@ pub mod player;
pub mod profiling;
pub mod render;
pub mod stage;
pub mod vulnerable;
pub use self::audio::*;
pub use self::blinking::*;
@@ -31,4 +30,3 @@ pub use self::player::*;
pub use self::profiling::*;
pub use self::render::*;
pub use self::stage::*;
pub use self::vulnerable::*;

3
src/systems/render.rs
View File

@@ -57,7 +57,8 @@ pub fn directional_render_system(
if let Some(texture) = texture {
if !stopped {
texture.tick(dt.0);
let ticks = (dt.0 * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
texture.tick(ticks);
}
let new_tile = *texture.current_tile();
if renderable.sprite != new_tile {

33
src/systems/vulnerable.rs
View File

@@ -1,33 +0,0 @@
use bevy_ecs::{
query::With,
system::{Commands, Query, Res},
};
use crate::constants::animation::FRIGHTENED_FLASH_START_TICKS;
use crate::systems::{Ghost, GhostAnimations, GhostCollider, Vulnerable};
/// System that decrements the remaining_ticks on Vulnerable components and removes them when they reach zero
pub fn vulnerable_tick_system(
mut commands: Commands,
animations: Res<GhostAnimations>,
mut vulnerable_query: Query<(bevy_ecs::entity::Entity, &mut Vulnerable, &Ghost), With<GhostCollider>>,
) {
for (entity, mut vulnerable, ghost_type) in vulnerable_query.iter_mut() {
if vulnerable.remaining_ticks > 0 {
vulnerable.remaining_ticks -= 1;
}
// When 2 seconds are remaining, start flashing
if vulnerable.remaining_ticks == FRIGHTENED_FLASH_START_TICKS {
if let Some(animation_set) = animations.0.get(ghost_type) {
if let Some(animation) = animation_set.frightened_flashing() {
commands.entity(entity).insert(animation.clone());
}
}
}
if vulnerable.remaining_ticks == 0 {
commands.entity(entity).remove::<Vulnerable>();
}
}
}