fix: correctly unhide in second pre-freeze stage

src/game.rs

@@ -2,13 +2,13 @@
 
 include!(concat!(env!("OUT_DIR"), "/atlas_data.rs"));
 
-use crate::constants::CANVAS_SIZE;
+use crate::constants::{MapTile, CANVAS_SIZE};
 use crate::error::{GameError, GameResult, TextureError};
 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, MovementModifiers};
+use crate::systems::{self, ghost_collision_system, present_system, Hidden, MovementModifiers};
 
 use crate::systems::movement::{BufferedDirection, Position, Velocity};
 use crate::systems::profiling::SystemId;
@@ -21,13 +21,15 @@ use crate::systems::{
     PacmanCollider, PlayerBundle, PlayerControlled, Renderable, ScoreResource, StartupSequence, SystemTimings,
 };
 use crate::texture::animated::AnimatedTexture;
+use crate::texture::sprite::AtlasTile;
 use bevy_ecs::event::EventRegistry;
 use bevy_ecs::observer::Trigger;
-use bevy_ecs::schedule::{IntoScheduleConfigs, Schedule, SystemSet};
-use bevy_ecs::system::{NonSendMut, Res, ResMut};
+use bevy_ecs::schedule::common_conditions::resource_changed;
+use bevy_ecs::schedule::{Condition, IntoScheduleConfigs, Schedule, SystemSet};
+use bevy_ecs::system::ResMut;
 use bevy_ecs::world::World;
 use sdl2::image::LoadTexture;
-use sdl2::render::{Canvas, ScaleMode, TextureCreator};
+use sdl2::render::{BlendMode, Canvas, ScaleMode, TextureCreator};
 use sdl2::rwops::RWops;
 use sdl2::video::{Window, WindowContext};
 use sdl2::EventPump;
@@ -81,14 +83,7 @@ impl Game {
         texture_creator: &'static mut TextureCreator<WindowContext>,
         event_pump: &'static mut EventPump,
     ) -> GameResult<Game> {
-        let mut world = World::default();
-        let mut schedule = Schedule::default();
         let ttf_context = Box::leak(Box::new(sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?));
-
-        EventRegistry::register_event::<GameError>(&mut world);
-        EventRegistry::register_event::<GameEvent>(&mut world);
-        EventRegistry::register_event::<AudioEvent>(&mut world);
-
         let mut backbuffer = texture_creator
             .create_texture_target(None, CANVAS_SIZE.x, CANVAS_SIZE.y)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
@@ -104,6 +99,9 @@ impl Game {
         let mut debug_texture = texture_creator
             .create_texture_target(None, output_size.0, output_size.1)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
+
+        // Debug texture is copied over the backbuffer, it requires transparency abilities
+        debug_texture.set_blend_mode(BlendMode::Blend);
         debug_texture.set_scale_mode(ScaleMode::Nearest);
 
         let font_data = get_asset_bytes(Asset::Font)?;
@@ -149,11 +147,10 @@ impl Game {
             .map_err(|e| GameError::Sdl(e.to_string()))?;
 
         let map = Map::new(constants::RAW_BOARD)?;
-        let pacman_start_node = map.start_positions.pacman;
 
+        // Create directional animated textures for Pac-Man
         let mut textures = [None, None, None, None];
         let mut stopped_textures = [None, None, None, None];
-
         for direction in Direction::DIRECTIONS {
             let moving_prefix = match direction {
                 Direction::Up => "pacman/up",
@@ -179,7 +176,9 @@ impl Game {
 
         let player = PlayerBundle {
             player: PlayerControlled,
-            position: Position::Stopped { node: pacman_start_node },
+            position: Position::Stopped {
+                node: map.start_positions.pacman,
+            },
             velocity: Velocity {
                 speed: 1.15,
                 direction: Direction::Left,
@@ -202,9 +201,12 @@ impl Game {
             pacman_collider: PacmanCollider,
         };
 
-        // Spawn player and attach initial state bundle
-        let player_entity = world.spawn(player).id();
-        world.entity_mut(player_entity).insert(Frozen);
+        let mut world = World::default();
+        let mut schedule = Schedule::default();
+
+        EventRegistry::register_event::<GameError>(&mut world);
+        EventRegistry::register_event::<GameEvent>(&mut world);
+        EventRegistry::register_event::<AudioEvent>(&mut world);
 
         world.insert_non_send_resource(atlas);
         world.insert_non_send_resource(event_pump);
@@ -225,6 +227,7 @@ impl Game {
         world.insert_resource(DebugState::default());
         world.insert_resource(AudioState::default());
         world.insert_resource(CursorPosition::default());
+        world.insert_resource(StartupSequence::new(60 * 3, 60));
 
         world.add_observer(
             |event: Trigger<GameEvent>, mut state: ResMut<GlobalState>, _score: ResMut<ScoreResource>| {
@@ -248,25 +251,17 @@ impl Game {
         let blinking_system = profile(SystemId::Blinking, blinking_system);
         let directional_render_system = profile(SystemId::DirectionalRender, directional_render_system);
         let dirty_render_system = profile(SystemId::DirtyRender, dirty_render_system);
-        let hud_render_system = profile(SystemId::HudRender, hud_render_system);
         let render_system = profile(SystemId::Render, render_system);
+        let hud_render_system = profile(SystemId::HudRender, hud_render_system);
         let debug_render_system = profile(SystemId::DebugRender, debug_render_system);
+        let present_system = profile(SystemId::Present, present_system);
 
-        let present_system = profile(
-            SystemId::Present,
-            |mut canvas: NonSendMut<&mut Canvas<Window>>, debug_state: Res<DebugState>, mut dirty: ResMut<RenderDirty>| {
-                if dirty.0 || debug_state.enabled {
-                    // Only copy backbuffer to main canvas if debug rendering is off
-                    // (debug rendering draws directly to main canvas)
-                    if !debug_state.enabled {
-                        canvas.present();
-                    }
-                    dirty.0 = false;
-                }
-            },
-        );
+        let forced_dirty_system = |mut dirty: ResMut<RenderDirty>| {
+            dirty.0 = true;
+        };
 
         schedule.add_systems((
+            forced_dirty_system.run_if(resource_changed::<ScoreResource>.or(resource_changed::<StartupSequence>)),
             (
                 input_system,
                 player_control_system,
@@ -291,41 +286,46 @@ impl Game {
                 .chain(),
         ));
 
-        world.insert_resource(StartupSequence::new(60 * 3, 60));
+        // Spawn player and attach initial state bundle
+        world.spawn(player).insert((Frozen, Hidden));
 
         // Spawn ghosts
         Self::spawn_ghosts(&mut world)?;
 
-        // Spawn items
         let pellet_sprite = SpriteAtlas::get_tile(world.non_send_resource::<SpriteAtlas>(), "maze/pellet.png")
             .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("maze/pellet.png".to_string())))?;
         let energizer_sprite = SpriteAtlas::get_tile(world.non_send_resource::<SpriteAtlas>(), "maze/energizer.png")
             .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("maze/energizer.png".to_string())))?;
 
-        let nodes: Vec<_> = world.resource::<Map>().iter_nodes().map(|(id, tile)| (*id, *tile)).collect();
-
-        for (node_id, tile) in nodes {
-            let (item_type, sprite, size) = match tile {
-                crate::constants::MapTile::Pellet => (EntityType::Pellet, pellet_sprite, constants::CELL_SIZE as f32 * 0.4),
-                crate::constants::MapTile::PowerPellet => {
-                    (EntityType::PowerPellet, energizer_sprite, constants::CELL_SIZE as f32 * 0.95)
-                }
-                _ => continue,
-            };
+        // Build a list of item entities to spawn from the map
+        let nodes: Vec<(usize, EntityType, AtlasTile, f32)> = world
+            .resource::<Map>()
+            .iter_nodes()
+            .filter_map(|(id, tile)| match tile {
+                MapTile::Pellet => Some((*id, EntityType::Pellet, pellet_sprite, constants::CELL_SIZE as f32 * 0.4)),
+                MapTile::PowerPellet => Some((
+                    *id,
+                    EntityType::PowerPellet,
+                    energizer_sprite,
+                    constants::CELL_SIZE as f32 * 0.95,
+                )),
+                _ => None,
+            })
+            .collect();
 
+        // Construct and spawn the item entities
+        for (id, item_type, sprite, size) in nodes {
             let mut item = world.spawn(ItemBundle {
-                position: Position::Stopped { node: node_id },
+                position: Position::Stopped { node: id },
                 sprite: Renderable { sprite, layer: 1 },
                 entity_type: item_type,
                 collider: Collider { size },
                 item_collider: ItemCollider,
             });
 
+            // Make power pellets blink
             if item_type == EntityType::PowerPellet {
-                item.insert(Blinking {
-                    timer: 0.0,
-                    interval: 0.2,
-                });
+                item.insert((Frozen, Blinking::new(0.2)));
             }
         }
 
@@ -435,7 +435,7 @@ impl Game {
                 }
             };
 
-            world.spawn(ghost).insert(Frozen);
+            world.spawn(ghost).insert((Frozen, Hidden));
         }
 
         Ok(())

src/platform/desktop.rs

@@ -24,44 +24,6 @@ impl CommonPlatform for Platform {
     }
 
     fn init_console(&self) -> Result<(), PlatformError> {
-        #[cfg(windows)]
-        {
-            unsafe {
-                use winapi::{
-                    shared::ntdef::NULL,
-                    um::{
-                        fileapi::{CreateFileA, OPEN_EXISTING},
-                        handleapi::INVALID_HANDLE_VALUE,
-                        processenv::SetStdHandle,
-                        winbase::{STD_ERROR_HANDLE, STD_OUTPUT_HANDLE},
-                        wincon::{AttachConsole, GetConsoleWindow},
-                        winnt::{FILE_SHARE_READ, FILE_SHARE_WRITE, GENERIC_READ, GENERIC_WRITE},
-                    },
-                };
-
-                if !std::ptr::eq(GetConsoleWindow(), std::ptr::null_mut()) {
-                    return Ok(());
-                }
-
-                if AttachConsole(winapi::um::wincon::ATTACH_PARENT_PROCESS) != 0 {
-                    let handle = CreateFileA(
-                        c"CONOUT$".as_ptr(),
-                        GENERIC_READ | GENERIC_WRITE,
-                        FILE_SHARE_READ | FILE_SHARE_WRITE,
-                        std::ptr::null_mut(),
-                        OPEN_EXISTING,
-                        0,
-                        NULL,
-                    );
-
-                    if handle != INVALID_HANDLE_VALUE {
-                        SetStdHandle(STD_OUTPUT_HANDLE, handle);
-                        SetStdHandle(STD_ERROR_HANDLE, handle);
-                    }
-                }
-            }
-        }
-
         Ok(())
     }
 

src/systems/blinking.rs

@@ -7,36 +7,57 @@ use bevy_ecs::{
 
 use crate::systems::{
     components::{DeltaTime, Renderable},
-    Hidden,
+    Frozen, Hidden,
 };
 
-#[derive(Component)]
+#[derive(Component, Debug)]
 pub struct Blinking {
     pub timer: f32,
     pub interval: f32,
 }
 
+impl Blinking {
+    pub fn new(interval: f32) -> Self {
+        Self { timer: 0.0, interval }
+    }
+}
+
 /// Updates blinking entities by toggling their visibility at regular intervals.
 ///
 /// This system manages entities that have both `Blinking` and `Renderable` components,
 /// accumulating time and toggling visibility when the specified interval is reached.
+#[allow(clippy::type_complexity)]
 pub fn blinking_system(
     mut commands: Commands,
     time: Res<DeltaTime>,
-    mut query: Query<(Entity, &mut Blinking, Has<Hidden>), With<Renderable>>,
+    mut query: Query<(Entity, &mut Blinking, Has<Hidden>, Has<Frozen>), With<Renderable>>,
 ) {
-    for (entity, mut blinking, hidden) in query.iter_mut() {
+    for (entity, mut blinking, hidden, frozen) in query.iter_mut() {
+        // If the entity is frozen, blinking is disabled and the entity is unhidden (if it was hidden)
+        if frozen {
+            if hidden {
+                commands.entity(entity).remove::<Hidden>();
+            }
+
+            continue;
+        }
+
+        // Increase the timer by the delta time
         blinking.timer += time.0;
 
-        if blinking.timer >= blinking.interval {
-            blinking.timer = 0.0;
+        // If the timer is less than the interval, there's nothing to do yet
+        if blinking.timer < blinking.interval {
+            continue;
+        }
 
-            // Add or remove the Visible component based on whether it is currently in the query
+        // Subtract the interval (allows for the timer to retain partial interval progress)
+        blinking.timer -= blinking.interval;
+
+        // Toggle the Hidden component
         if hidden {
             commands.entity(entity).remove::<Hidden>();
         } else {
             commands.entity(entity).insert(Hidden);
         }
     }
-    }
 }

src/systems/debug.rs

@@ -3,7 +3,7 @@ use std::cmp::Ordering;
 
 use crate::constants::BOARD_PIXEL_OFFSET;
 use crate::map::builder::Map;
-use crate::systems::{BackbufferResource, Collider, CursorPosition, Position, SystemTimings};
+use crate::systems::{Collider, CursorPosition, Position, SystemTimings};
 use bevy_ecs::resource::Resource;
 use bevy_ecs::system::{NonSendMut, Query, Res};
 use glam::{IVec2, UVec2, Vec2};
@@ -89,7 +89,6 @@ fn render_timing_display(
 #[allow(clippy::too_many_arguments)]
 pub fn debug_render_system(
     mut canvas: NonSendMut<&mut Canvas<Window>>,
-    backbuffer: NonSendMut<BackbufferResource>,
     mut debug_texture: NonSendMut<DebugTextureResource>,
     debug_font: NonSendMut<DebugFontResource>,
     debug_state: Res<DebugState>,
@@ -104,18 +103,6 @@ pub fn debug_render_system(
     let scale =
         (UVec2::from(canvas.output_size().unwrap()).as_vec2() / UVec2::from(canvas.logical_size()).as_vec2()).min_element();
 
-    // Copy the current backbuffer to the debug texture
-    canvas
-        .with_texture_canvas(&mut debug_texture.0, |debug_canvas| {
-            // Clear the debug canvas
-            debug_canvas.set_draw_color(Color::BLACK);
-            debug_canvas.clear();
-
-            // Copy the backbuffer to the debug canvas
-            debug_canvas.copy(&backbuffer.0, None, None).unwrap();
-        })
-        .unwrap();
-
     // Get texture creator before entering the closure to avoid borrowing conflicts
     let mut texture_creator = canvas.texture_creator();
     let font = &debug_font.0;
@@ -128,8 +115,11 @@ pub fn debug_render_system(
     // Draw debug info on the high-resolution debug texture
     canvas
         .with_texture_canvas(&mut debug_texture.0, |debug_canvas| {
-            // Find the closest node to the cursor
+            // Clear the debug canvas
+            debug_canvas.set_draw_color(Color::RGBA(0, 0, 0, 0));
+            debug_canvas.clear();
 
+            // Find the closest node to the cursor
             let closest_node = if let Some(cursor_world_pos) = cursor_world_pos {
                 map.graph
                     .nodes()
@@ -214,8 +204,4 @@ pub fn debug_render_system(
             render_timing_display(debug_canvas, &mut texture_creator, &timings, font);
         })
         .unwrap();
-
-    // Draw the debug texture directly onto the main canvas at full resolution
-    canvas.copy(&debug_texture.0, None, None).unwrap();
-    canvas.present();
 }

src/systems/render.rs

@@ -1,7 +1,10 @@
 use crate::constants::CANVAS_SIZE;
 use crate::error::{GameError, TextureError};
 use crate::map::builder::Map;
-use crate::systems::{DeltaTime, DirectionalAnimated, Position, Renderable, ScoreResource, StartupSequence, Velocity};
+use crate::systems::{
+    DebugState, DebugTextureResource, DeltaTime, DirectionalAnimated, Position, Renderable, ScoreResource, StartupSequence,
+    Velocity,
+};
 use crate::texture::sprite::SpriteAtlas;
 use crate::texture::text::TextTexture;
 use bevy_ecs::component::Component;
@@ -13,7 +16,7 @@ use bevy_ecs::resource::Resource;
 use bevy_ecs::system::{NonSendMut, Query, Res, ResMut};
 use sdl2::pixels::Color;
 use sdl2::rect::{Point, Rect};
-use sdl2::render::{Canvas, Texture};
+use sdl2::render::{BlendMode, Canvas, Texture};
 use sdl2::video::Window;
 
 #[derive(Resource, Default)]
@@ -25,10 +28,11 @@ pub struct Hidden;
 #[allow(clippy::type_complexity)]
 pub fn dirty_render_system(
     mut dirty: ResMut<RenderDirty>,
-    changed_renderables: Query<(), Or<(Changed<Renderable>, Changed<Position>)>>,
+    changed: Query<(), Or<(Changed<Renderable>, Changed<Position>)>>,
+    removed_hidden: RemovedComponents<Hidden>,
     removed_renderables: RemovedComponents<Renderable>,
 ) {
-    if !changed_renderables.is_empty() || !removed_renderables.is_empty() {
+    if !changed.is_empty() || !removed_hidden.is_empty() || !removed_renderables.is_empty() {
         dirty.0 = true;
     }
 }
@@ -74,12 +78,14 @@ pub struct BackbufferResource(pub Texture<'static>);
 
 /// Renders the HUD (score, lives, etc.) on top of the game.
 pub fn hud_render_system(
+    mut backbuffer: NonSendMut<BackbufferResource>,
     mut canvas: NonSendMut<&mut Canvas<Window>>,
     mut atlas: NonSendMut<SpriteAtlas>,
     score: Res<ScoreResource>,
     startup: Res<StartupSequence>,
     mut errors: EventWriter<GameError>,
 ) {
+    let _ = canvas.with_texture_canvas(&mut backbuffer.0, |canvas| {
         let mut text_renderer = TextTexture::new(1.0);
 
         // Render lives and high score text in white
@@ -87,7 +93,7 @@ pub fn hud_render_system(
         let lives_text = format!("{lives}UP   HIGH SCORE   ");
         let lives_position = glam::UVec2::new(4 + 8 * 3, 2); // x_offset + lives_offset * 8, y_offset
 
-    if let Err(e) = text_renderer.render(&mut canvas, &mut atlas, &lives_text, lives_position) {
+        if let Err(e) = text_renderer.render(canvas, &mut atlas, &lives_text, lives_position) {
             errors.write(TextureError::RenderFailed(format!("Failed to render lives text: {}", e)).into());
         }
 
@@ -96,7 +102,7 @@ pub fn hud_render_system(
         let score_offset = 7 - (score_text.len() as i32);
         let score_position = glam::UVec2::new(4 + 8 * score_offset as u32, 10); // x_offset + score_offset * 8, 8 + y_offset
 
-    if let Err(e) = text_renderer.render(&mut canvas, &mut atlas, &score_text, score_position) {
+        if let Err(e) = text_renderer.render(canvas, &mut atlas, &score_text, score_position) {
             errors.write(TextureError::RenderFailed(format!("Failed to render score text: {}", e)).into());
         }
 
@@ -108,7 +114,7 @@ pub fn hud_render_system(
             let ready_text = "READY!";
             let ready_width = text_renderer.text_width(ready_text);
             let ready_position = glam::UVec2::new((CANVAS_SIZE.x - ready_width) / 2, 160);
-        if let Err(e) = text_renderer.render_with_color(&mut canvas, &mut atlas, ready_text, ready_position, Color::YELLOW) {
+            if let Err(e) = text_renderer.render_with_color(canvas, &mut atlas, ready_text, ready_position, Color::YELLOW) {
                 errors.write(TextureError::RenderFailed(format!("Failed to render READY text: {}", e)).into());
             }
 
@@ -118,12 +124,13 @@ pub fn hud_render_system(
                 let player_one_position = glam::UVec2::new((CANVAS_SIZE.x - player_one_width) / 2, 113);
 
                 if let Err(e) =
-                text_renderer.render_with_color(&mut canvas, &mut atlas, player_one_text, player_one_position, Color::CYAN)
+                    text_renderer.render_with_color(canvas, &mut atlas, player_one_text, player_one_position, Color::CYAN)
                 {
                     errors.write(TextureError::RenderFailed(format!("Failed to render PLAYER ONE text: {}", e)).into());
                 }
             }
         }
+    });
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -184,3 +191,25 @@ pub fn render_system(
 
     canvas.copy(&backbuffer.0, None, None).unwrap();
 }
+
+pub fn present_system(
+    mut canvas: NonSendMut<&mut Canvas<Window>>,
+    mut dirty: ResMut<RenderDirty>,
+    backbuffer: NonSendMut<BackbufferResource>,
+    debug_texture: NonSendMut<DebugTextureResource>,
+    debug_state: Res<DebugState>,
+) {
+    if dirty.0 {
+        // Copy the backbuffer to the main canvas
+        canvas.copy(&backbuffer.0, None, None).unwrap();
+
+        // Copy the debug texture to the canvas
+        if debug_state.enabled {
+            canvas.set_blend_mode(BlendMode::Blend);
+            canvas.copy(&debug_texture.0, None, None).unwrap();
+        }
+
+        canvas.present();
+        dirty.0 = false;
+    }
+}

src/systems/stage.rs

@@ -6,7 +6,7 @@ use bevy_ecs::{
 };
 use tracing::debug;
 
-use crate::systems::{Frozen, GhostCollider, Hidden, PlayerControlled};
+use crate::systems::{Blinking, Frozen, GhostCollider, Hidden, PlayerControlled};
 
 #[derive(Resource, Debug, Clone, Copy)]
 pub enum StartupSequence {
@@ -72,17 +72,27 @@ impl StartupSequence {
 pub fn startup_stage_system(
     mut startup: ResMut<StartupSequence>,
     mut commands: Commands,
+    mut blinking_query: Query<Entity, With<Blinking>>,
     mut player_query: Query<Entity, With<PlayerControlled>>,
     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 { .. }) => {}
-            (StartupSequence::CharactersVisible { .. }, StartupSequence::GameActive) => {
-                // Remove Frozen/Hidden tags from all entities and enable player input
+            (StartupSequence::TextOnly { .. }, StartupSequence::CharactersVisible { .. }) => {
+                // Unhide the player & ghosts
                 for entity in player_query.iter_mut().chain(ghost_query.iter_mut()) {
-                    commands.entity(entity).remove::<(Frozen, Hidden)>();
+                    commands.entity(entity).remove::<Hidden>();
+                }
+            }
+            (StartupSequence::CharactersVisible { .. }, StartupSequence::GameActive) => {
+                // Unfreeze the player & ghosts & pellet blinking
+                for entity in player_query
+                    .iter_mut()
+                    .chain(ghost_query.iter_mut())
+                    .chain(blinking_query.iter_mut())
+                {
+                    commands.entity(entity).remove::<Frozen>();
                 }
             }
             _ => {}