fix: add expected MovementModifiers to spawn_test_player to fix movement tests

src/game.rs

@@ -8,18 +8,17 @@ use crate::events::GameEvent;
 use crate::map::builder::Map;
 use crate::map::direction::Direction;
 use crate::systems::blinking::Blinking;
-use crate::systems::{self, ghost_collision_system};
+use crate::systems::{self, ghost_collision_system, MovementModifiers};
 
 use crate::systems::movement::{BufferedDirection, Position, Velocity};
 use crate::systems::profiling::SystemId;
 use crate::systems::render::RenderDirty;
 use crate::systems::{
     audio_system, blinking_system, collision_system, debug_render_system, directional_render_system, dirty_render_system,
-    ghost_movement_system, hud_render_system, item_system, profile, ready_visibility_system, render_system, AudioEvent,
-    AudioResource, AudioState, BackbufferResource, Collider, DebugFontResource, DebugState, DebugTextureResource, DeltaTime,
-    DirectionalAnimated, EntityType, Frozen, Ghost, GhostBundle, GhostCollider, GlobalState, ItemBundle, ItemCollider,
-    MapTextureResource, PacmanCollider, PlayerBundle, PlayerControlled, PlayerStateBundle, Renderable, ScoreResource,
-    StartupSequence, SystemTimings,
+    ghost_movement_system, hud_render_system, item_system, profile, render_system, AudioEvent, AudioResource, AudioState,
+    BackbufferResource, Collider, DebugFontResource, DebugState, DebugTextureResource, DeltaTime, DirectionalAnimated,
+    EntityType, Frozen, Ghost, GhostBundle, GhostCollider, GlobalState, ItemBundle, ItemCollider, MapTextureResource,
+    PacmanCollider, PlayerBundle, PlayerControlled, Renderable, ScoreResource, StartupSequence, SystemTimings,
 };
 use crate::texture::animated::AnimatedTexture;
 use bevy_ecs::event::EventRegistry;
@@ -185,12 +184,12 @@ impl Game {
                 speed: 1.15,
                 direction: Direction::Left,
             },
+            movement_modifiers: MovementModifiers::default(),
             buffered_direction: BufferedDirection::None,
             sprite: Renderable {
                 sprite: SpriteAtlas::get_tile(&atlas, "pacman/full.png")
                     .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
                 layer: 0,
-                visible: true,
             },
             directional_animated: DirectionalAnimated {
                 textures,
@@ -205,7 +204,6 @@ impl Game {
 
         // Spawn player and attach initial state bundle
         let player_entity = world.spawn(player).id();
-        world.entity_mut(player_entity).insert(PlayerStateBundle::default());
         world.entity_mut(player_entity).insert(Frozen);
 
         world.insert_non_send_resource(atlas);
@@ -282,7 +280,6 @@ impl Game {
             (collision_system, ghost_collision_system, item_system).chain(),
             audio_system,
             blinking_system,
-            ready_visibility_system,
             (
                 directional_render_system,
                 dirty_render_system,
@@ -318,11 +315,7 @@ impl Game {
 
             let mut item = world.spawn(ItemBundle {
                 position: Position::Stopped { node: node_id },
-                sprite: Renderable {
-                    sprite,
-                    layer: 1,
-                    visible: true,
-                },
+                sprite: Renderable { sprite, layer: 1 },
                 entity_type: item_type,
                 collider: Collider { size },
                 item_collider: ItemCollider,
@@ -429,7 +422,6 @@ impl Game {
                             },
                         )?,
                         layer: 0,
-                        visible: true,
                     },
                     directional_animated: DirectionalAnimated {
                         textures,

src/systems/blinking.rs

@@ -1,9 +1,14 @@
 use bevy_ecs::{
     component::Component,
-    system::{Query, Res},
+    entity::Entity,
+    query::{Has, With},
+    system::{Commands, Query, Res},
 };
 
-use crate::systems::components::{DeltaTime, Renderable};
+use crate::systems::{
+    components::{DeltaTime, Renderable},
+    Hidden,
+};
 
 #[derive(Component)]
 pub struct Blinking {
@@ -15,13 +20,23 @@ pub struct Blinking {
 ///
 /// This system manages entities that have both `Blinking` and `Renderable` components,
 /// accumulating time and toggling visibility when the specified interval is reached.
-pub fn blinking_system(time: Res<DeltaTime>, mut query: Query<(&mut Blinking, &mut Renderable)>) {
-    for (mut blinking, mut renderable) in query.iter_mut() {
+pub fn blinking_system(
+    mut commands: Commands,
+    time: Res<DeltaTime>,
+    mut query: Query<(Entity, &mut Blinking, Has<Hidden>), With<Renderable>>,
+) {
+    for (entity, mut blinking, hidden) in query.iter_mut() {
         blinking.timer += time.0;
 
         if blinking.timer >= blinking.interval {
             blinking.timer = 0.0;
-            renderable.visible = !renderable.visible;
+
+            // Add or remove the Visible component based on whether it is currently in the query
+            if hidden {
+                commands.entity(entity).remove::<Hidden>();
+            } else {
+                commands.entity(entity).insert(Hidden);
+            }
         }
     }
 }

src/systems/components.rs

@@ -5,7 +5,7 @@ use crate::{
     map::graph::TraversalFlags,
     systems::{
         movement::{BufferedDirection, Position, Velocity},
-        Collider, GhostCollider, ItemCollider, PacmanCollider, PlayerLifecycle,
+        Collider, GhostCollider, ItemCollider, PacmanCollider,
     },
     texture::{animated::AnimatedTexture, sprite::AtlasTile},
 };
@@ -93,7 +93,6 @@ impl EntityType {
 pub struct Renderable {
     pub sprite: AtlasTile,
     pub layer: u8,
-    pub visible: bool,
 }
 
 /// A component for entities that have a directional animated texture.
@@ -161,14 +160,8 @@ pub struct PlayerBundle {
     pub directional_animated: DirectionalAnimated,
     pub entity_type: EntityType,
     pub collider: Collider,
-    pub pacman_collider: PacmanCollider,
-}
-
-/// Convenience bundle for attaching the hybrid FSM to the player entity
-#[derive(Bundle, Default)]
-pub struct PlayerStateBundle {
-    pub lifecycle: PlayerLifecycle,
     pub movement_modifiers: MovementModifiers,
+    pub pacman_collider: PacmanCollider,
 }
 
 #[derive(Bundle)]

src/systems/player.rs

@@ -1,5 +1,4 @@
 use bevy_ecs::{
-    component::Component,
     event::{EventReader, EventWriter},
     query::{With, Without},
     system::{Query, Res, ResMut},
@@ -17,28 +16,6 @@ use crate::{
     },
 };
 
-/// Lifecycle state for the player entity.
-#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
-pub enum PlayerLifecycle {
-    Spawning,
-    Alive,
-    Dying,
-    Respawning,
-}
-
-impl PlayerLifecycle {
-    /// Returns true when gameplay input and movement should be active
-    pub fn is_interactive(self) -> bool {
-        matches!(self, PlayerLifecycle::Alive)
-    }
-}
-
-impl Default for PlayerLifecycle {
-    fn default() -> Self {
-        PlayerLifecycle::Spawning
-    }
-}
-
 pub fn can_traverse(entity_type: EntityType, edge: Edge) -> bool {
     let entity_flags = entity_type.traversal_flags();
     edge.traversal_flags.contains(entity_flags)
@@ -64,7 +41,7 @@ pub fn player_control_system(
             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() {
+                    let mut buffered_direction = match players.single_mut() {
                         Ok(tuple) => tuple,
                         Err(e) => {
                             errors.write(GameError::InvalidState(format!(
@@ -101,22 +78,16 @@ pub fn player_control_system(
 /// Handles movement logic including buffered direction changes, edge traversal validation, and continuous movement between nodes.
 /// When stopped, prioritizes buffered directions for responsive controls, falling back to current direction.
 /// Supports movement chaining within a single frame when traveling at high speeds.
+#[allow(clippy::type_complexity)]
 pub fn player_movement_system(
     map: Res<Map>,
     delta_time: Res<DeltaTime>,
     mut entities: Query<
-        (
-            &PlayerLifecycle,
-            &MovementModifiers,
-            &mut Position,
-            &mut Velocity,
-            &mut BufferedDirection,
-        ),
+        (&MovementModifiers, &mut Position, &mut Velocity, &mut BufferedDirection),
         (With<PlayerControlled>, Without<Frozen>),
     >,
-    // mut errors: EventWriter<GameError>,
 ) {
-    for (lifecycle, modifiers, mut position, mut velocity, mut buffered_direction) in entities.iter_mut() {
+    for (modifiers, mut position, mut velocity, mut buffered_direction) in entities.iter_mut() {
         // Decrement the buffered direction remaining time
         if let BufferedDirection::Some {
             direction,

src/systems/render.rs

@@ -1,15 +1,13 @@
 use crate::constants::CANVAS_SIZE;
 use crate::error::{GameError, TextureError};
 use crate::map::builder::Map;
-use crate::systems::{
-    Blinking, DeltaTime, DirectionalAnimated, EntityType, GhostCollider, PlayerControlled, Position, Renderable, ScoreResource,
-    StartupSequence, Velocity,
-};
+use crate::systems::{DeltaTime, DirectionalAnimated, Position, Renderable, ScoreResource, StartupSequence, Velocity};
 use crate::texture::sprite::SpriteAtlas;
 use crate::texture::text::TextTexture;
+use bevy_ecs::component::Component;
 use bevy_ecs::entity::Entity;
 use bevy_ecs::event::EventWriter;
-use bevy_ecs::query::{Changed, Or, With, Without};
+use bevy_ecs::query::{Changed, Or, Without};
 use bevy_ecs::removal_detection::RemovedComponents;
 use bevy_ecs::resource::Resource;
 use bevy_ecs::system::{NonSendMut, Query, Res, ResMut};
@@ -21,6 +19,9 @@ use sdl2::video::Window;
 #[derive(Resource, Default)]
 pub struct RenderDirty(pub bool);
 
+#[derive(Component)]
+pub struct Hidden;
+
 #[allow(clippy::type_complexity)]
 pub fn dirty_render_system(
     mut dirty: ResMut<RenderDirty>,
@@ -71,56 +72,6 @@ pub struct MapTextureResource(pub Texture<'static>);
 /// A non-send resource for the backbuffer texture. This just wraps the texture with a type so it can be differentiated when exposed as a resource.
 pub struct BackbufferResource(pub Texture<'static>);
 
-/// Updates entity visibility based on StartupSequence stages
-pub fn ready_visibility_system(
-    startup: Res<StartupSequence>,
-    mut player_query: Query<&mut Renderable, (With<PlayerControlled>, Without<GhostCollider>)>,
-    mut ghost_query: Query<&mut Renderable, (With<GhostCollider>, Without<PlayerControlled>)>,
-    mut energizer_query: Query<(&mut Blinking, &EntityType)>,
-) {
-    match *startup {
-        StartupSequence::TextOnly { .. } => {
-            // Hide player and ghosts, disable energizer blinking
-            if let Ok(mut renderable) = player_query.single_mut() {
-                renderable.visible = false;
-            }
-
-            for mut renderable in ghost_query.iter_mut() {
-                renderable.visible = false;
-            }
-
-            // Disable energizer blinking in text-only stage
-            for (mut blinking, entity_type) in energizer_query.iter_mut() {
-                if matches!(entity_type, EntityType::PowerPellet) {
-                    blinking.timer = 0.0; // Reset timer to prevent blinking
-                }
-            }
-        }
-        StartupSequence::CharactersVisible { .. } => {
-            // Show player and ghosts, enable energizer blinking
-            if let Ok(mut renderable) = player_query.single_mut() {
-                renderable.visible = true;
-            }
-
-            for mut renderable in ghost_query.iter_mut() {
-                renderable.visible = true;
-            }
-
-            // Energizer blinking is handled by the blinking system
-        }
-        StartupSequence::GameActive => {
-            // All entities are visible and blinking is normal
-            if let Ok(mut renderable) = player_query.single_mut() {
-                renderable.visible = true;
-            }
-
-            for mut renderable in ghost_query.iter_mut() {
-                renderable.visible = true;
-            }
-        }
-    }
-}
-
 /// Renders the HUD (score, lives, etc.) on top of the game.
 pub fn hud_render_system(
     mut canvas: NonSendMut<&mut Canvas<Window>>,
@@ -183,7 +134,7 @@ pub fn render_system(
     mut atlas: NonSendMut<SpriteAtlas>,
     map: Res<Map>,
     dirty: Res<RenderDirty>,
-    renderables: Query<(Entity, &Renderable, &Position)>,
+    renderables: Query<(Entity, &Renderable, &Position), Without<Hidden>>,
     mut errors: EventWriter<GameError>,
 ) {
     if !dirty.0 {
@@ -207,10 +158,6 @@ pub fn render_system(
                 .sort_by_key::<(Entity, &Renderable, &Position), _>(|(_, renderable, _)| renderable.layer)
                 .rev()
             {
-                if !renderable.visible {
-                    continue;
-                }
-
                 let pos = position.get_pixel_position(&map.graph);
                 match pos {
                     Ok(pos) => {

src/systems/stage.rs

@@ -4,8 +4,9 @@ use bevy_ecs::{
     resource::Resource,
     system::{Commands, Query, ResMut},
 };
+use tracing::debug;
 
-use crate::systems::{Frozen, GhostCollider, PlayerControlled};
+use crate::systems::{Frozen, GhostCollider, Hidden, PlayerControlled};
 
 #[derive(Resource, Debug, Clone, Copy)]
 pub enum StartupSequence {
@@ -75,21 +76,14 @@ pub fn startup_stage_system(
     mut ghost_query: Query<Entity, With<GhostCollider>>,
 ) {
     if let Some((from, to)) = startup.tick() {
+        debug!("StartupSequence transition from {from:?} to {to:?}");
         match (from, to) {
-            (StartupSequence::TextOnly { .. }, StartupSequence::CharactersVisible { .. }) => {
-                // TODO: Add TextOnly tag component to hide entities
-                // TODO: Add CharactersVisible tag component to show entities
-                // TODO: Remove TextOnly tag component
-            }
+            // (StartupSequence::TextOnly { .. }, StartupSequence::CharactersVisible { .. }) => {}
             (StartupSequence::CharactersVisible { .. }, StartupSequence::GameActive) => {
-                // Remove Frozen tag from all entities and enable player input
+                // Remove Frozen/Hidden tags from all entities and enable player input
                 for entity in player_query.iter_mut().chain(ghost_query.iter_mut()) {
-                    tracing::info!("Removing Frozen component from entity {}", entity);
-                    commands.entity(entity).remove::<Frozen>();
+                    commands.entity(entity).remove::<(Frozen, Hidden)>();
                 }
-
-                // TODO: Add GameActive tag component
-                // TODO: Remove CharactersVisible tag component
             }
             _ => {}
         }

tests/player.rs

@@ -9,7 +9,7 @@ use pacman::{
     },
     systems::{
         can_traverse, player_control_system, player_movement_system, AudioState, BufferedDirection, DebugState, DeltaTime,
-        EntityType, GlobalState, PlayerControlled, Position, Velocity,
+        EntityType, GlobalState, MovementModifiers, PlayerControlled, Position, Velocity,
     },
 };
 
@@ -49,6 +49,7 @@ fn spawn_test_player(world: &mut World) -> Entity {
             },
             BufferedDirection::None,
             EntityType::Player,
+            MovementModifiers::default(),
         ))
         .id()
 }