mirror of
https://github.com/Xevion/Pac-Man.git
synced 2025-12-06 07:15:41 -06:00
Compare commits
6 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
6637691157 | ||
|
|
c79ba0d824 | ||
|
|
b1b03b0e9c | ||
|
|
a62ae8dfe7 | ||
|
|
a21459f337 | ||
|
|
b53db3788d |
114
Cargo.lock
generated
114
Cargo.lock
generated
@@ -618,7 +618,8 @@ dependencies = [
|
||||
"tracing",
|
||||
"tracing-error",
|
||||
"tracing-subscriber",
|
||||
"winapi",
|
||||
"windows",
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -1304,6 +1305,108 @@ version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
|
||||
|
||||
[[package]]
|
||||
name = "windows"
|
||||
version = "0.61.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
|
||||
dependencies = [
|
||||
"windows-collections",
|
||||
"windows-core",
|
||||
"windows-future",
|
||||
"windows-link",
|
||||
"windows-numerics",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-collections"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
|
||||
dependencies = [
|
||||
"windows-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-core"
|
||||
version = "0.61.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
|
||||
dependencies = [
|
||||
"windows-implement",
|
||||
"windows-interface",
|
||||
"windows-link",
|
||||
"windows-result",
|
||||
"windows-strings",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-future"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
|
||||
dependencies = [
|
||||
"windows-core",
|
||||
"windows-link",
|
||||
"windows-threading",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-implement"
|
||||
version = "0.60.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-interface"
|
||||
version = "0.59.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-link"
|
||||
version = "0.1.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
|
||||
|
||||
[[package]]
|
||||
name = "windows-numerics"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
|
||||
dependencies = [
|
||||
"windows-core",
|
||||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-result"
|
||||
version = "0.3.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
|
||||
dependencies = [
|
||||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-strings"
|
||||
version = "0.4.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
|
||||
dependencies = [
|
||||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-sys"
|
||||
version = "0.60.2"
|
||||
@@ -1345,6 +1448,15 @@ dependencies = [
|
||||
"windows_x86_64_msvc 0.53.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-threading"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
|
||||
dependencies = [
|
||||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows_aarch64_gnullvm"
|
||||
version = "0.52.6"
|
||||
|
||||
@@ -35,9 +35,12 @@ lto = true
|
||||
panic = "abort"
|
||||
opt-level = "z"
|
||||
|
||||
[target.'cfg(target_os = "windows")'.dependencies.winapi]
|
||||
version = "0.3"
|
||||
features = ["consoleapi", "fileapi", "handleapi", "processenv", "winbase", "wincon", "winnt", "winuser", "windef", "minwindef"]
|
||||
[target.'cfg(target_os = "windows")'.dependencies]
|
||||
windows = { version = "0.61.3", features = ["Win32_Security", "Win32_Storage_FileSystem", "Win32_System_Console"] }
|
||||
windows-sys = { version = "0.60.2", features = ["Win32_System_Console"] }
|
||||
|
||||
[target.'cfg(not(target_os = "windows"))'.dependencies]
|
||||
libc = "0.2"
|
||||
|
||||
|
||||
[target.'cfg(target_os = "emscripten")'.dependencies.sdl2]
|
||||
|
||||
32
src/app.rs
32
src/app.rs
@@ -25,8 +25,8 @@ pub struct App {
|
||||
impl App {
|
||||
/// Initializes SDL subsystems, creates the game window, and sets up the game state.
|
||||
///
|
||||
/// Performs comprehensive initialization including video/audio subsystems, platform-specific
|
||||
/// console setup, window creation with proper scaling, and canvas configuration. All SDL
|
||||
/// Performs comprehensive initialization including video/audio subsystems,
|
||||
/// window creation with proper scaling, and canvas configuration. All SDL
|
||||
/// resources are leaked to maintain 'static lifetimes required by the game architecture.
|
||||
///
|
||||
/// # Errors
|
||||
@@ -44,9 +44,6 @@ impl App {
|
||||
let event_pump: &'static mut EventPump =
|
||||
Box::leak(Box::new(sdl_context.event_pump().map_err(|e| GameError::Sdl(e.to_string()))?));
|
||||
|
||||
// Initialize platform-specific console
|
||||
get_platform().init_console()?;
|
||||
|
||||
let window = video_subsystem
|
||||
.window(
|
||||
"Pac-Man",
|
||||
@@ -96,31 +93,6 @@ impl App {
|
||||
{
|
||||
let start = Instant::now();
|
||||
|
||||
// for event in self
|
||||
// .game
|
||||
// .world
|
||||
// .get_non_send_resource_mut::<&'static mut EventPump>()
|
||||
// .unwrap()
|
||||
// .poll_iter()
|
||||
// {
|
||||
// match event {
|
||||
// Event::Window { win_event, .. } => match win_event {
|
||||
// WindowEvent::FocusGained => {
|
||||
// self.focused = true;
|
||||
// }
|
||||
// WindowEvent::FocusLost => {
|
||||
// self.focused = false;
|
||||
// }
|
||||
// _ => {}
|
||||
// },
|
||||
// Event::MouseMotion { x, y, .. } => {
|
||||
// // Convert window coordinates to logical coordinates
|
||||
// self.cursor_pos = Vec2::new(x as f32, y as f32);
|
||||
// }
|
||||
// _ => {}
|
||||
// }
|
||||
// }
|
||||
|
||||
let dt = self.last_tick.elapsed().as_secs_f32();
|
||||
self.last_tick = Instant::now();
|
||||
|
||||
|
||||
@@ -33,14 +33,12 @@ pub const BOARD_PIXEL_OFFSET: UVec2 = UVec2::new(BOARD_CELL_OFFSET.x * CELL_SIZE
|
||||
|
||||
/// Animation timing constants for ghost state management
|
||||
pub mod animation {
|
||||
/// Normal ghost movement animation speed (frames per second)
|
||||
pub const GHOST_NORMAL_SPEED: f32 = 0.2;
|
||||
/// Eaten ghost (eyes) animation speed (frames per second)
|
||||
pub const GHOST_EATEN_SPEED: f32 = 0.1;
|
||||
/// Frightened ghost animation speed (frames per second)
|
||||
pub const GHOST_FRIGHTENED_SPEED: f32 = 0.2;
|
||||
/// Frightened ghost flashing animation speed (frames per second)
|
||||
pub const GHOST_FLASHING_SPEED: f32 = 0.15;
|
||||
/// Normal ghost movement animation speed (ticks per frame at 60 ticks/sec)
|
||||
pub const GHOST_NORMAL_SPEED: u16 = 12;
|
||||
/// Eaten ghost (eyes) animation speed (ticks per frame at 60 ticks/sec)
|
||||
pub const GHOST_EATEN_SPEED: u16 = 6;
|
||||
/// Frightened ghost animation speed (ticks per frame at 60 ticks/sec)
|
||||
pub const GHOST_FRIGHTENED_SPEED: u16 = 12;
|
||||
|
||||
/// Time in ticks when frightened ghosts start flashing (2 seconds at 60 FPS)
|
||||
pub const FRIGHTENED_FLASH_START_TICKS: u32 = 120;
|
||||
@@ -51,6 +49,26 @@ pub const CANVAS_SIZE: UVec2 = UVec2::new(
|
||||
(BOARD_CELL_SIZE.y + BOARD_CELL_OFFSET.y) * CELL_SIZE,
|
||||
);
|
||||
|
||||
/// Collider size constants for different entity types
|
||||
pub mod collider {
|
||||
use super::CELL_SIZE;
|
||||
|
||||
/// Collider size for player and ghosts (1.375x cell size)
|
||||
pub const PLAYER_GHOST_SIZE: f32 = CELL_SIZE as f32 * 1.375;
|
||||
/// Collider size for pellets (0.4x cell size)
|
||||
pub const PELLET_SIZE: f32 = CELL_SIZE as f32 * 0.4;
|
||||
/// Collider size for power pellets/energizers (0.95x cell size)
|
||||
pub const POWER_PELLET_SIZE: f32 = CELL_SIZE as f32 * 0.95;
|
||||
}
|
||||
|
||||
/// UI and rendering constants
|
||||
pub mod ui {
|
||||
/// Debug font size in points
|
||||
pub const DEBUG_FONT_SIZE: u16 = 12;
|
||||
/// Power pellet blink rate in seconds
|
||||
pub const POWER_PELLET_BLINK_RATE: f32 = 0.2;
|
||||
}
|
||||
|
||||
/// Map tile types that define gameplay behavior and collision properties.
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
pub enum MapTile {
|
||||
@@ -102,3 +120,17 @@ pub const RAW_BOARD: [&str; BOARD_CELL_SIZE.y as usize] = [
|
||||
"#..........................#",
|
||||
"############################",
|
||||
];
|
||||
|
||||
/// Game initialization constants
|
||||
pub mod startup {
|
||||
/// Number of frames for the startup sequence (3 seconds at 60 FPS)
|
||||
pub const STARTUP_FRAMES: u32 = 60 * 3;
|
||||
/// Number of ticks per frame during startup
|
||||
pub const STARTUP_TICKS_PER_FRAME: u32 = 60;
|
||||
}
|
||||
|
||||
/// Game mechanics constants
|
||||
pub mod mechanics {
|
||||
/// Player movement speed multiplier
|
||||
pub const PLAYER_SPEED: f32 = 1.15;
|
||||
}
|
||||
|
||||
@@ -78,9 +78,6 @@ pub enum ParseError {
|
||||
/// Errors related to texture operations.
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum TextureError {
|
||||
#[error("Animated texture error: {0}")]
|
||||
Animated(#[from] AnimatedTextureError),
|
||||
|
||||
#[error("Failed to load texture: {0}")]
|
||||
LoadFailed(String),
|
||||
|
||||
@@ -94,12 +91,6 @@ pub enum TextureError {
|
||||
RenderFailed(String),
|
||||
}
|
||||
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum AnimatedTextureError {
|
||||
#[error("Frame duration must be positive, got {0}")]
|
||||
InvalidFrameDuration(f32),
|
||||
}
|
||||
|
||||
/// Errors related to entity operations.
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum EntityError {
|
||||
|
||||
344
src/game.rs
344
src/game.rs
@@ -2,25 +2,28 @@
|
||||
|
||||
include!(concat!(env!("OUT_DIR"), "/atlas_data.rs"));
|
||||
|
||||
use crate::constants::{animation, MapTile, CANVAS_SIZE};
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::constants::{self, animation, 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::components::{GhostAnimation, GhostState, LastAnimationState};
|
||||
use crate::systems::movement::{BufferedDirection, Position, Velocity};
|
||||
use crate::systems::profiling::SystemId;
|
||||
use crate::systems::render::RenderDirty;
|
||||
use crate::systems::{self, ghost_collision_system, present_system, Hidden, MovementModifiers, NodeId};
|
||||
use crate::systems::{self, ghost_collision_system, present_system, Hidden, LinearAnimation, MovementModifiers, NodeId};
|
||||
use crate::systems::{
|
||||
audio_system, blinking_system, collision_system, debug_render_system, directional_render_system, dirty_render_system,
|
||||
eaten_ghost_system, ghost_movement_system, ghost_state_animation_system, hud_render_system, item_system, profile,
|
||||
eaten_ghost_system, ghost_movement_system, ghost_state_system, hud_render_system, item_system, linear_render_system, profile,
|
||||
render_system, AudioEvent, AudioResource, AudioState, BackbufferResource, Collider, DebugFontResource, DebugState,
|
||||
DebugTextureResource, DeltaTime, DirectionalAnimated, EntityType, Frozen, Ghost, GhostAnimationSet, GhostAnimations,
|
||||
GhostBundle, GhostCollider, GlobalState, ItemBundle, ItemCollider, MapTextureResource, PacmanCollider, PlayerBundle,
|
||||
PlayerControlled, Renderable, ScoreResource, StartupSequence, SystemTimings,
|
||||
DebugTextureResource, DeltaTime, DirectionalAnimation, EntityType, Frozen, Ghost, GhostAnimations, GhostBundle,
|
||||
GhostCollider, GlobalState, ItemBundle, ItemCollider, MapTextureResource, PacmanCollider, PlayerBundle, PlayerControlled,
|
||||
Renderable, ScoreResource, StartupSequence, SystemTimings,
|
||||
};
|
||||
use crate::texture::animated::AnimatedTexture;
|
||||
use crate::texture::animated::{DirectionalTiles, TileSequence};
|
||||
use crate::texture::sprite::AtlasTile;
|
||||
use bevy_ecs::event::EventRegistry;
|
||||
use bevy_ecs::observer::Trigger;
|
||||
@@ -33,11 +36,9 @@ use sdl2::render::{BlendMode, Canvas, ScaleMode, TextureCreator};
|
||||
use sdl2::rwops::RWops;
|
||||
use sdl2::video::{Window, WindowContext};
|
||||
use sdl2::EventPump;
|
||||
use smallvec::smallvec;
|
||||
|
||||
use crate::{
|
||||
asset::{get_asset_bytes, Asset},
|
||||
constants,
|
||||
events::GameCommand,
|
||||
map::render::MapRenderer,
|
||||
systems::input::{Bindings, CursorPosition},
|
||||
@@ -109,7 +110,7 @@ impl Game {
|
||||
let static_font_data: &'static [u8] = Box::leak(font_data.to_vec().into_boxed_slice());
|
||||
let font_asset = RWops::from_bytes(static_font_data).map_err(|_| GameError::Sdl("Failed to load font".to_string()))?;
|
||||
let debug_font = ttf_context
|
||||
.load_font_from_rwops(font_asset, 12)
|
||||
.load_font_from_rwops(font_asset, constants::ui::DEBUG_FONT_SIZE)
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
|
||||
// Initialize audio system
|
||||
@@ -150,30 +151,61 @@ impl Game {
|
||||
let map = Map::new(constants::RAW_BOARD)?;
|
||||
|
||||
// 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",
|
||||
Direction::Down => "pacman/down",
|
||||
Direction::Left => "pacman/left",
|
||||
Direction::Right => "pacman/right",
|
||||
};
|
||||
let moving_tiles = smallvec![
|
||||
SpriteAtlas::get_tile(&atlas, &format!("{moving_prefix}_a.png"))
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_a.png"))))?,
|
||||
SpriteAtlas::get_tile(&atlas, &format!("{moving_prefix}_b.png"))
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_b.png"))))?,
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/full.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
|
||||
];
|
||||
let up_moving_tiles = [
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/up_a.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/up_a.png".to_string())))?,
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/up_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/up_b.png".to_string())))?,
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/full.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
|
||||
];
|
||||
let down_moving_tiles = [
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/down_a.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/down_a.png".to_string())))?,
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/down_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/down_b.png".to_string())))?,
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/full.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
|
||||
];
|
||||
let left_moving_tiles = [
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/left_a.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/left_a.png".to_string())))?,
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/left_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/left_b.png".to_string())))?,
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/full.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
|
||||
];
|
||||
let right_moving_tiles = [
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/right_a.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/right_a.png".to_string())))?,
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/right_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/right_b.png".to_string())))?,
|
||||
SpriteAtlas::get_tile(&atlas, "pacman/full.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
|
||||
];
|
||||
|
||||
let stopped_tiles = smallvec![SpriteAtlas::get_tile(&atlas, &format!("{moving_prefix}_b.png"))
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_b.png"))))?];
|
||||
let moving_tiles = DirectionalTiles::new(
|
||||
TileSequence::new(&up_moving_tiles),
|
||||
TileSequence::new(&down_moving_tiles),
|
||||
TileSequence::new(&left_moving_tiles),
|
||||
TileSequence::new(&right_moving_tiles),
|
||||
);
|
||||
|
||||
textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.08)?);
|
||||
stopped_textures[direction.as_usize()] = Some(AnimatedTexture::new(stopped_tiles, 0.1)?);
|
||||
}
|
||||
let up_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/up_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/up_b.png".to_string())))?;
|
||||
let down_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/down_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/down_b.png".to_string())))?;
|
||||
let left_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/left_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/left_b.png".to_string())))?;
|
||||
let right_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/right_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/right_b.png".to_string())))?;
|
||||
|
||||
let stopped_tiles = DirectionalTiles::new(
|
||||
TileSequence::new(&[up_stopped_tile]),
|
||||
TileSequence::new(&[down_stopped_tile]),
|
||||
TileSequence::new(&[left_stopped_tile]),
|
||||
TileSequence::new(&[right_stopped_tile]),
|
||||
);
|
||||
|
||||
let player = PlayerBundle {
|
||||
player: PlayerControlled,
|
||||
@@ -181,7 +213,7 @@ impl Game {
|
||||
node: map.start_positions.pacman,
|
||||
},
|
||||
velocity: Velocity {
|
||||
speed: 1.15,
|
||||
speed: constants::mechanics::PLAYER_SPEED,
|
||||
direction: Direction::Left,
|
||||
},
|
||||
movement_modifiers: MovementModifiers::default(),
|
||||
@@ -191,13 +223,10 @@ impl Game {
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
|
||||
layer: 0,
|
||||
},
|
||||
directional_animated: DirectionalAnimated {
|
||||
textures,
|
||||
stopped_textures,
|
||||
},
|
||||
directional_animation: DirectionalAnimation::new(moving_tiles, stopped_tiles, 5),
|
||||
entity_type: EntityType::Player,
|
||||
collider: Collider {
|
||||
size: constants::CELL_SIZE as f32 * 1.375,
|
||||
size: constants::collider::PLAYER_GHOST_SIZE,
|
||||
},
|
||||
pacman_collider: PacmanCollider,
|
||||
};
|
||||
@@ -220,7 +249,10 @@ 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.insert_resource(StartupSequence::new(
|
||||
constants::startup::STARTUP_FRAMES,
|
||||
constants::startup::STARTUP_TICKS_PER_FRAME,
|
||||
));
|
||||
|
||||
world.insert_non_send_resource(atlas);
|
||||
world.insert_non_send_resource(event_pump);
|
||||
@@ -247,17 +279,18 @@ impl Game {
|
||||
let ghost_movement_system = profile(SystemId::Ghost, ghost_movement_system);
|
||||
let collision_system = profile(SystemId::Collision, collision_system);
|
||||
let ghost_collision_system = profile(SystemId::GhostCollision, ghost_collision_system);
|
||||
let vulnerable_tick_system = profile(SystemId::Ghost, systems::vulnerable_tick_system);
|
||||
|
||||
let item_system = profile(SystemId::Item, item_system);
|
||||
let audio_system = profile(SystemId::Audio, audio_system);
|
||||
let blinking_system = profile(SystemId::Blinking, blinking_system);
|
||||
let directional_render_system = profile(SystemId::DirectionalRender, directional_render_system);
|
||||
let linear_render_system = profile(SystemId::LinearRender, linear_render_system);
|
||||
let dirty_render_system = profile(SystemId::DirtyRender, dirty_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 ghost_state_animation_system = profile(SystemId::GhostStateAnimation, ghost_state_animation_system);
|
||||
let unified_ghost_state_system = profile(SystemId::GhostStateAnimation, ghost_state_system);
|
||||
|
||||
let forced_dirty_system = |mut dirty: ResMut<RenderDirty>| {
|
||||
dirty.0 = true;
|
||||
@@ -275,13 +308,13 @@ impl Game {
|
||||
player_tunnel_slowdown_system,
|
||||
ghost_movement_system,
|
||||
profile(SystemId::EatenGhost, eaten_ghost_system),
|
||||
vulnerable_tick_system,
|
||||
ghost_state_animation_system,
|
||||
unified_ghost_state_system,
|
||||
(collision_system, ghost_collision_system, item_system).chain(),
|
||||
audio_system,
|
||||
blinking_system,
|
||||
(
|
||||
directional_render_system,
|
||||
linear_render_system,
|
||||
dirty_render_system,
|
||||
render_system,
|
||||
hud_render_system,
|
||||
@@ -307,12 +340,12 @@ impl Game {
|
||||
.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::Pellet => Some((*id, EntityType::Pellet, pellet_sprite, constants::collider::PELLET_SIZE)),
|
||||
MapTile::PowerPellet => Some((
|
||||
*id,
|
||||
EntityType::PowerPellet,
|
||||
energizer_sprite,
|
||||
constants::CELL_SIZE as f32 * 0.95,
|
||||
constants::collider::POWER_PELLET_SIZE,
|
||||
)),
|
||||
_ => None,
|
||||
})
|
||||
@@ -330,7 +363,7 @@ impl Game {
|
||||
|
||||
// Make power pellets blink
|
||||
if item_type == EntityType::PowerPellet {
|
||||
item.insert((Frozen, Blinking::new(0.2)));
|
||||
item.insert((Frozen, Blinking::new(constants::ui::POWER_PELLET_BLINK_RATE)));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -358,7 +391,7 @@ impl Game {
|
||||
for (ghost_type, start_node) in ghost_start_positions {
|
||||
// Create the ghost bundle in a separate scope to manage borrows
|
||||
let ghost = {
|
||||
let animations = world.resource::<GhostAnimations>().0.get(&ghost_type).unwrap().clone();
|
||||
let animations = *world.resource::<GhostAnimations>().get_normal(&ghost_type).unwrap();
|
||||
let atlas = world.non_send_resource::<SpriteAtlas>();
|
||||
|
||||
GhostBundle {
|
||||
@@ -379,12 +412,14 @@ impl Game {
|
||||
)?,
|
||||
layer: 0,
|
||||
},
|
||||
directional_animated: animations.normal().unwrap().clone(),
|
||||
directional_animation: animations,
|
||||
entity_type: EntityType::Ghost,
|
||||
collider: Collider {
|
||||
size: crate::constants::CELL_SIZE as f32 * 1.375,
|
||||
size: constants::collider::PLAYER_GHOST_SIZE,
|
||||
},
|
||||
ghost_collider: GhostCollider,
|
||||
ghost_state: GhostState::Normal,
|
||||
last_animation_state: LastAnimationState(GhostAnimation::Normal),
|
||||
}
|
||||
};
|
||||
|
||||
@@ -395,103 +430,144 @@ impl Game {
|
||||
}
|
||||
|
||||
fn create_ghost_animations(atlas: &SpriteAtlas) -> GameResult<GhostAnimations> {
|
||||
let mut animations = std::collections::HashMap::new();
|
||||
// Eaten (eyes) animations - single tile per direction
|
||||
let up_eye = atlas
|
||||
.get_tile("ghost/eyes/up.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/up.png".to_string())))?;
|
||||
let down_eye = atlas
|
||||
.get_tile("ghost/eyes/down.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/down.png".to_string())))?;
|
||||
let left_eye = atlas
|
||||
.get_tile("ghost/eyes/left.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/left.png".to_string())))?;
|
||||
let right_eye = atlas
|
||||
.get_tile("ghost/eyes/right.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/right.png".to_string())))?;
|
||||
|
||||
let eyes_tiles = DirectionalTiles::new(
|
||||
TileSequence::new(&[up_eye]),
|
||||
TileSequence::new(&[down_eye]),
|
||||
TileSequence::new(&[left_eye]),
|
||||
TileSequence::new(&[right_eye]),
|
||||
);
|
||||
let eyes = DirectionalAnimation::new(eyes_tiles, eyes_tiles, animation::GHOST_EATEN_SPEED);
|
||||
|
||||
let mut animations = HashMap::new();
|
||||
|
||||
for ghost_type in [Ghost::Blinky, Ghost::Pinky, Ghost::Inky, Ghost::Clyde] {
|
||||
// Normal animations
|
||||
let mut normal_textures = [None, None, None, None];
|
||||
for direction in Direction::DIRECTIONS {
|
||||
let dir_str = direction.as_ref();
|
||||
let tile_a = atlas
|
||||
.get_tile(&format!("ghost/{}/{}_a.png", ghost_type.as_str(), dir_str))
|
||||
// Normal animations - create directional tiles for each direction
|
||||
let up_tiles = [
|
||||
atlas
|
||||
.get_tile(&format!("ghost/{}/up_a.png", ghost_type.as_str()))
|
||||
.ok_or_else(|| {
|
||||
GameError::Texture(TextureError::AtlasTileNotFound(format!(
|
||||
"ghost/{}/{}_a.png",
|
||||
ghost_type.as_str(),
|
||||
dir_str
|
||||
"ghost/{}/up_a.png",
|
||||
ghost_type.as_str()
|
||||
)))
|
||||
})?;
|
||||
let tile_b = atlas
|
||||
.get_tile(&format!("ghost/{}/{}_b.png", ghost_type.as_str(), dir_str))
|
||||
})?,
|
||||
atlas
|
||||
.get_tile(&format!("ghost/{}/up_b.png", ghost_type.as_str()))
|
||||
.ok_or_else(|| {
|
||||
GameError::Texture(TextureError::AtlasTileNotFound(format!(
|
||||
"ghost/{}/{}_b.png",
|
||||
ghost_type.as_str(),
|
||||
dir_str
|
||||
"ghost/{}/up_b.png",
|
||||
ghost_type.as_str()
|
||||
)))
|
||||
})?;
|
||||
let tiles = smallvec![tile_a, tile_b];
|
||||
normal_textures[direction.as_usize()] = Some(AnimatedTexture::new(tiles, animation::GHOST_NORMAL_SPEED)?);
|
||||
}
|
||||
let normal = DirectionalAnimated {
|
||||
textures: normal_textures.clone(),
|
||||
stopped_textures: normal_textures,
|
||||
};
|
||||
})?,
|
||||
];
|
||||
let down_tiles = [
|
||||
atlas
|
||||
.get_tile(&format!("ghost/{}/down_a.png", ghost_type.as_str()))
|
||||
.ok_or_else(|| {
|
||||
GameError::Texture(TextureError::AtlasTileNotFound(format!(
|
||||
"ghost/{}/down_a.png",
|
||||
ghost_type.as_str()
|
||||
)))
|
||||
})?,
|
||||
atlas
|
||||
.get_tile(&format!("ghost/{}/down_b.png", ghost_type.as_str()))
|
||||
.ok_or_else(|| {
|
||||
GameError::Texture(TextureError::AtlasTileNotFound(format!(
|
||||
"ghost/{}/down_b.png",
|
||||
ghost_type.as_str()
|
||||
)))
|
||||
})?,
|
||||
];
|
||||
let left_tiles = [
|
||||
atlas
|
||||
.get_tile(&format!("ghost/{}/left_a.png", ghost_type.as_str()))
|
||||
.ok_or_else(|| {
|
||||
GameError::Texture(TextureError::AtlasTileNotFound(format!(
|
||||
"ghost/{}/left_a.png",
|
||||
ghost_type.as_str()
|
||||
)))
|
||||
})?,
|
||||
atlas
|
||||
.get_tile(&format!("ghost/{}/left_b.png", ghost_type.as_str()))
|
||||
.ok_or_else(|| {
|
||||
GameError::Texture(TextureError::AtlasTileNotFound(format!(
|
||||
"ghost/{}/left_b.png",
|
||||
ghost_type.as_str()
|
||||
)))
|
||||
})?,
|
||||
];
|
||||
let right_tiles = [
|
||||
atlas
|
||||
.get_tile(&format!("ghost/{}/right_a.png", ghost_type.as_str()))
|
||||
.ok_or_else(|| {
|
||||
GameError::Texture(TextureError::AtlasTileNotFound(format!(
|
||||
"ghost/{}/right_a.png",
|
||||
ghost_type.as_str()
|
||||
)))
|
||||
})?,
|
||||
atlas
|
||||
.get_tile(&format!("ghost/{}/right_b.png", ghost_type.as_str()))
|
||||
.ok_or_else(|| {
|
||||
GameError::Texture(TextureError::AtlasTileNotFound(format!(
|
||||
"ghost/{}/right_b.png",
|
||||
ghost_type.as_str()
|
||||
)))
|
||||
})?,
|
||||
];
|
||||
|
||||
// Eaten (eyes) animations
|
||||
let mut eaten_textures = [None, None, None, None];
|
||||
for direction in Direction::DIRECTIONS {
|
||||
let dir_str = direction.as_ref();
|
||||
let tile = atlas
|
||||
.get_tile(&format!("ghost/eyes/{}.png", dir_str))
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("ghost/eyes/{}.png", dir_str))))?;
|
||||
eaten_textures[direction.as_usize()] = Some(AnimatedTexture::new(smallvec![tile], animation::GHOST_EATEN_SPEED)?);
|
||||
}
|
||||
let eaten = DirectionalAnimated {
|
||||
textures: eaten_textures.clone(),
|
||||
stopped_textures: eaten_textures,
|
||||
};
|
||||
let normal_moving = DirectionalTiles::new(
|
||||
TileSequence::new(&up_tiles),
|
||||
TileSequence::new(&down_tiles),
|
||||
TileSequence::new(&left_tiles),
|
||||
TileSequence::new(&right_tiles),
|
||||
);
|
||||
let normal = DirectionalAnimation::new(normal_moving, normal_moving, animation::GHOST_NORMAL_SPEED);
|
||||
|
||||
animations.insert(
|
||||
ghost_type,
|
||||
GhostAnimationSet::new(
|
||||
normal,
|
||||
DirectionalAnimated::default(), // Placeholder for frightened
|
||||
DirectionalAnimated::default(), // Placeholder for frightened_flashing
|
||||
eaten,
|
||||
animations.insert(ghost_type, normal);
|
||||
}
|
||||
|
||||
let (frightened, frightened_flashing) = {
|
||||
// Load frightened animation tiles (same for all ghosts)
|
||||
let frightened_blue_a = atlas
|
||||
.get_tile("ghost/frightened/blue_a.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/blue_a.png".to_string())))?;
|
||||
let frightened_blue_b = atlas
|
||||
.get_tile("ghost/frightened/blue_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/blue_b.png".to_string())))?;
|
||||
let frightened_white_a = atlas
|
||||
.get_tile("ghost/frightened/white_a.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/white_a.png".to_string())))?;
|
||||
let frightened_white_b = atlas
|
||||
.get_tile("ghost/frightened/white_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/white_b.png".to_string())))?;
|
||||
|
||||
(
|
||||
LinearAnimation::new(
|
||||
TileSequence::new(&[frightened_blue_a, frightened_blue_b]),
|
||||
animation::GHOST_NORMAL_SPEED,
|
||||
),
|
||||
);
|
||||
}
|
||||
LinearAnimation::new(
|
||||
TileSequence::new(&[frightened_blue_a, frightened_white_a, frightened_blue_b, frightened_white_b]),
|
||||
animation::GHOST_FRIGHTENED_SPEED,
|
||||
),
|
||||
)
|
||||
};
|
||||
|
||||
// Frightened animations (same for all ghosts)
|
||||
let frightened_blue_a = atlas
|
||||
.get_tile("ghost/frightened/blue_a.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/blue_a.png".to_string())))?;
|
||||
let frightened_blue_b = atlas
|
||||
.get_tile("ghost/frightened/blue_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/blue_b.png".to_string())))?;
|
||||
let frightened_white_a = atlas
|
||||
.get_tile("ghost/frightened/white_a.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/white_a.png".to_string())))?;
|
||||
let frightened_white_b = atlas
|
||||
.get_tile("ghost/frightened/white_b.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/white_b.png".to_string())))?;
|
||||
|
||||
let frightened_anim = AnimatedTexture::new(
|
||||
smallvec![frightened_blue_a, frightened_blue_b],
|
||||
animation::GHOST_FRIGHTENED_SPEED,
|
||||
)?;
|
||||
let flashing_anim = AnimatedTexture::new(
|
||||
smallvec![frightened_blue_a, frightened_white_a, frightened_blue_b, frightened_white_b],
|
||||
animation::GHOST_FLASHING_SPEED,
|
||||
)?;
|
||||
|
||||
let frightened_da = DirectionalAnimated::from_animation(frightened_anim);
|
||||
let frightened_flashing_da = DirectionalAnimated::from_animation(flashing_anim);
|
||||
|
||||
for ghost_type in [Ghost::Blinky, Ghost::Pinky, Ghost::Inky, Ghost::Clyde] {
|
||||
let entry = animations.get_mut(&ghost_type).unwrap();
|
||||
entry.animations.insert(
|
||||
crate::systems::GhostAnimation::Frightened { flash: false },
|
||||
frightened_da.clone(),
|
||||
);
|
||||
entry.animations.insert(
|
||||
crate::systems::GhostAnimation::Frightened { flash: true },
|
||||
frightened_flashing_da.clone(),
|
||||
);
|
||||
}
|
||||
|
||||
Ok(GhostAnimations(animations))
|
||||
Ok(GhostAnimations::new(animations, eyes, frightened, frightened_flashing))
|
||||
}
|
||||
|
||||
/// Executes one frame of game logic by running all scheduled ECS systems.
|
||||
|
||||
25
src/main.rs
25
src/main.rs
@@ -1,9 +1,8 @@
|
||||
// Note: This disables the console window on Windows. We manually re-attach to the parent terminal or process later on.
|
||||
#![windows_subsystem = "windows"]
|
||||
|
||||
use crate::{app::App, constants::LOOP_TIME};
|
||||
use tracing::info;
|
||||
use tracing_error::ErrorLayer;
|
||||
use tracing_subscriber::layer::SubscriberExt;
|
||||
|
||||
mod app;
|
||||
mod asset;
|
||||
@@ -23,14 +22,22 @@ mod texture;
|
||||
/// This function initializes SDL, the window, the game state, and then enters
|
||||
/// the main game loop.
|
||||
pub fn main() {
|
||||
// Setup tracing
|
||||
let subscriber = tracing_subscriber::fmt()
|
||||
.with_ansi(cfg!(not(target_os = "emscripten")))
|
||||
.with_max_level(tracing::Level::DEBUG)
|
||||
.finish()
|
||||
.with(ErrorLayer::default());
|
||||
// Setup buffered tracing subscriber that will buffer logs until console is ready
|
||||
let switchable_writer = platform::tracing_buffer::setup_switchable_subscriber();
|
||||
|
||||
tracing::subscriber::set_global_default(subscriber).expect("Could not set global default");
|
||||
// Log early to show buffering is working
|
||||
tracing::debug!("Tracing subscriber initialized with buffering - logs will be buffered until console is ready");
|
||||
|
||||
// Initialize platform-specific console
|
||||
tracing::debug!("Starting console initialization...");
|
||||
platform::get_platform().init_console().expect("Could not initialize console");
|
||||
tracing::debug!("Console initialization completed");
|
||||
|
||||
// Now that console is initialized, flush buffered logs and switch to direct output
|
||||
tracing::debug!("Switching to direct logging mode and flushing buffer...");
|
||||
if let Err(e) = switchable_writer.switch_to_direct_mode() {
|
||||
tracing::warn!("Failed to flush buffered logs to console: {}", e);
|
||||
}
|
||||
|
||||
let mut app = App::new().expect("Could not create app");
|
||||
|
||||
|
||||
55
src/platform/buffered_writer.rs
Normal file
55
src/platform/buffered_writer.rs
Normal file
@@ -0,0 +1,55 @@
|
||||
//! Buffered writer for tracing logs that can store logs before console attachment.
|
||||
|
||||
use parking_lot::Mutex;
|
||||
use std::io::{self, Write};
|
||||
use std::sync::Arc;
|
||||
|
||||
/// A thread-safe buffered writer that stores logs in memory until flushed.
|
||||
#[derive(Clone)]
|
||||
pub struct BufferedWriter {
|
||||
buffer: Arc<Mutex<Vec<u8>>>,
|
||||
}
|
||||
|
||||
impl BufferedWriter {
|
||||
/// Creates a new buffered writer.
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
buffer: Arc::new(Mutex::new(Vec::new())),
|
||||
}
|
||||
}
|
||||
|
||||
/// Flushes all buffered content to the provided writer and clears the buffer.
|
||||
pub fn flush_to<W: Write>(&self, mut writer: W) -> io::Result<()> {
|
||||
let mut buffer = self.buffer.lock();
|
||||
if !buffer.is_empty() {
|
||||
writer.write_all(&buffer)?;
|
||||
writer.flush()?;
|
||||
buffer.clear();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Returns the current buffer size in bytes.
|
||||
pub fn buffer_size(&self) -> usize {
|
||||
self.buffer.lock().len()
|
||||
}
|
||||
}
|
||||
|
||||
impl Write for BufferedWriter {
|
||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||
let mut buffer = self.buffer.lock();
|
||||
buffer.extend_from_slice(buf);
|
||||
Ok(buf.len())
|
||||
}
|
||||
|
||||
fn flush(&mut self) -> io::Result<()> {
|
||||
// For buffered writer, flush is a no-op since we're storing in memory
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for BufferedWriter {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@ use std::time::Duration;
|
||||
use crate::asset::Asset;
|
||||
use crate::error::{AssetError, PlatformError};
|
||||
use crate::platform::CommonPlatform;
|
||||
use tracing::{debug, info, warn};
|
||||
|
||||
/// Desktop platform implementation.
|
||||
pub struct Platform;
|
||||
@@ -24,6 +25,29 @@ impl CommonPlatform for Platform {
|
||||
}
|
||||
|
||||
fn init_console(&self) -> Result<(), PlatformError> {
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use windows::Win32::System::Console::GetConsoleWindow;
|
||||
|
||||
// Check if we already have a console window
|
||||
if unsafe { !GetConsoleWindow().0.is_null() } {
|
||||
debug!("Already have a console window");
|
||||
return Ok(());
|
||||
} else {
|
||||
debug!("No existing console window found");
|
||||
}
|
||||
|
||||
if let Some(file_type) = Self::is_output_setup()? {
|
||||
debug!(r#type = file_type, "Existing output detected");
|
||||
} else {
|
||||
debug!("No existing output detected");
|
||||
|
||||
// Try to attach to parent console for direct cargo run
|
||||
Self::attach_to_parent_console()?;
|
||||
info!("Successfully attached to parent console");
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -42,3 +66,102 @@ impl CommonPlatform for Platform {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
impl Platform {
|
||||
/// Check if the output stream has been setup by a parent process
|
||||
fn is_output_setup() -> Result<Option<&'static str>, PlatformError> {
|
||||
use windows::Win32::Storage::FileSystem::{
|
||||
GetFileType, FILE_TYPE_CHAR, FILE_TYPE_DISK, FILE_TYPE_PIPE, FILE_TYPE_REMOTE, FILE_TYPE_UNKNOWN,
|
||||
};
|
||||
|
||||
use windows_sys::Win32::{
|
||||
Foundation::INVALID_HANDLE_VALUE,
|
||||
System::Console::{GetStdHandle, STD_OUTPUT_HANDLE},
|
||||
};
|
||||
|
||||
// Get the process's standard output handle, check if it's invalid
|
||||
let handle = match unsafe { GetStdHandle(STD_OUTPUT_HANDLE) } {
|
||||
INVALID_HANDLE_VALUE => {
|
||||
return Err(PlatformError::ConsoleInit("Invalid handle".to_string()));
|
||||
}
|
||||
handle => handle,
|
||||
};
|
||||
|
||||
// Identify the file type of the handle
|
||||
let (well_known, file_type) = match unsafe {
|
||||
use windows::Win32::Foundation::HANDLE;
|
||||
GetFileType(HANDLE(handle))
|
||||
} {
|
||||
FILE_TYPE_PIPE => (true, "pipe"),
|
||||
FILE_TYPE_CHAR => (true, "char"),
|
||||
FILE_TYPE_DISK => (true, "disk"),
|
||||
FILE_TYPE_UNKNOWN => (false, "unknown"),
|
||||
FILE_TYPE_REMOTE => (false, "remote"),
|
||||
unexpected => {
|
||||
warn!("Unexpected file type: {unexpected:?}");
|
||||
(false, "unknown")
|
||||
}
|
||||
};
|
||||
|
||||
debug!("File type: {file_type:?}, well known: {well_known}");
|
||||
|
||||
// If it's anything recognizable and valid, assume that a parent process has setup an output stream
|
||||
Ok(well_known.then(|| file_type))
|
||||
}
|
||||
|
||||
/// Try to attach to parent console
|
||||
fn attach_to_parent_console() -> Result<(), PlatformError> {
|
||||
use windows::{
|
||||
core::PCSTR,
|
||||
Win32::{
|
||||
Foundation::{GENERIC_READ, GENERIC_WRITE},
|
||||
Storage::FileSystem::{CreateFileA, FILE_FLAGS_AND_ATTRIBUTES, FILE_SHARE_READ, FILE_SHARE_WRITE, OPEN_EXISTING},
|
||||
System::Console::{
|
||||
AttachConsole, FreeConsole, SetStdHandle, ATTACH_PARENT_PROCESS, STD_ERROR_HANDLE, STD_OUTPUT_HANDLE,
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
// Attach the process to the parent's console
|
||||
unsafe { AttachConsole(ATTACH_PARENT_PROCESS) }
|
||||
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to attach to parent console: {:?}", e)))?;
|
||||
|
||||
let handle = unsafe {
|
||||
let pcstr = PCSTR::from_raw("CONOUT$\0".as_ptr());
|
||||
CreateFileA::<PCSTR>(
|
||||
pcstr,
|
||||
(GENERIC_READ | GENERIC_WRITE).0,
|
||||
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||||
None,
|
||||
OPEN_EXISTING,
|
||||
FILE_FLAGS_AND_ATTRIBUTES(0),
|
||||
None,
|
||||
)
|
||||
}
|
||||
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to create console handle: {:?}", e)))?;
|
||||
|
||||
// Set the console's output and then error handles
|
||||
if let Some(handle_error) = unsafe { SetStdHandle(STD_OUTPUT_HANDLE, handle) }
|
||||
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to set console output handle: {:?}", e)))
|
||||
.and_then(|_| {
|
||||
unsafe { SetStdHandle(STD_ERROR_HANDLE, handle) }
|
||||
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to set console error handle: {:?}", e)))
|
||||
})
|
||||
.err()
|
||||
{
|
||||
// If either set handle call fails, free the console
|
||||
unsafe { FreeConsole() }
|
||||
// Free the console if the SetStdHandle calls fail
|
||||
.map_err(|free_error| {
|
||||
PlatformError::ConsoleInit(format!(
|
||||
"Failed to free console after SetStdHandle failed: {free_error:?} ({handle_error:?})"
|
||||
))
|
||||
})
|
||||
// And then return the original error if the FreeConsole call succeeds
|
||||
.and(Err(handle_error))?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,6 +10,8 @@ mod desktop;
|
||||
#[cfg(target_os = "emscripten")]
|
||||
mod emscripten;
|
||||
|
||||
pub mod buffered_writer;
|
||||
pub mod tracing_buffer;
|
||||
/// Cross-platform abstraction layer providing unified APIs for platform-specific operations.
|
||||
pub trait CommonPlatform {
|
||||
/// Platform-specific sleep function (required due to Emscripten's non-standard sleep requirements).
|
||||
|
||||
91
src/platform/tracing_buffer.rs
Normal file
91
src/platform/tracing_buffer.rs
Normal file
@@ -0,0 +1,91 @@
|
||||
//! Buffered tracing setup for handling logs before console attachment.
|
||||
|
||||
use crate::platform::buffered_writer::BufferedWriter;
|
||||
use std::io;
|
||||
use tracing::Level;
|
||||
use tracing_error::ErrorLayer;
|
||||
use tracing_subscriber::fmt::MakeWriter;
|
||||
use tracing_subscriber::layer::SubscriberExt;
|
||||
|
||||
/// A writer that can switch between buffering and direct output.
|
||||
#[derive(Clone, Default)]
|
||||
pub struct SwitchableWriter {
|
||||
buffered_writer: BufferedWriter,
|
||||
direct_mode: std::sync::Arc<parking_lot::Mutex<bool>>,
|
||||
}
|
||||
|
||||
impl SwitchableWriter {
|
||||
pub fn switch_to_direct_mode(&self) -> io::Result<()> {
|
||||
// Get buffer size before flushing for debug logging
|
||||
let buffer_size = self.buffered_writer.buffer_size();
|
||||
|
||||
// First flush any buffered content
|
||||
self.buffered_writer.flush_to(io::stdout())?;
|
||||
|
||||
// Switch to direct mode
|
||||
*self.direct_mode.lock() = true;
|
||||
|
||||
// Log how much was buffered (this will now go directly to stdout)
|
||||
tracing::debug!("Flushed {} bytes of buffered logs to console", buffer_size);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl io::Write for SwitchableWriter {
|
||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||
if *self.direct_mode.lock() {
|
||||
io::stdout().write(buf)
|
||||
} else {
|
||||
self.buffered_writer.clone().write(buf)
|
||||
}
|
||||
}
|
||||
|
||||
fn flush(&mut self) -> io::Result<()> {
|
||||
if *self.direct_mode.lock() {
|
||||
io::stdout().flush()
|
||||
} else {
|
||||
// For buffered mode, flush is a no-op
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A make writer that uses the switchable writer.
|
||||
#[derive(Clone)]
|
||||
pub struct SwitchableMakeWriter {
|
||||
writer: SwitchableWriter,
|
||||
}
|
||||
|
||||
impl SwitchableMakeWriter {
|
||||
pub fn new(writer: SwitchableWriter) -> Self {
|
||||
Self { writer }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> MakeWriter<'a> for SwitchableMakeWriter {
|
||||
type Writer = SwitchableWriter;
|
||||
|
||||
fn make_writer(&'a self) -> Self::Writer {
|
||||
self.writer.clone()
|
||||
}
|
||||
}
|
||||
|
||||
/// Sets up a switchable tracing subscriber that can transition from buffered to direct output.
|
||||
///
|
||||
/// Returns the switchable writer that can be used to control the behavior.
|
||||
pub fn setup_switchable_subscriber() -> SwitchableWriter {
|
||||
let switchable_writer = SwitchableWriter::default();
|
||||
let make_writer = SwitchableMakeWriter::new(switchable_writer.clone());
|
||||
|
||||
let _subscriber = tracing_subscriber::fmt()
|
||||
.with_ansi(cfg!(not(target_os = "emscripten")))
|
||||
.with_max_level(Level::DEBUG)
|
||||
.with_writer(make_writer)
|
||||
.finish()
|
||||
.with(ErrorLayer::default());
|
||||
|
||||
tracing::subscriber::set_global_default(_subscriber).expect("Could not set global default switchable subscriber");
|
||||
|
||||
switchable_writer
|
||||
}
|
||||
@@ -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!");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use bevy_ecs::{bundle::Bundle, component::Component, resource::Resource};
|
||||
use bitflags::bitflags;
|
||||
|
||||
@@ -7,9 +9,11 @@ use crate::{
|
||||
movement::{BufferedDirection, Position, Velocity},
|
||||
Collider, GhostCollider, ItemCollider, PacmanCollider,
|
||||
},
|
||||
texture::{animated::AnimatedTexture, sprite::AtlasTile},
|
||||
texture::{
|
||||
animated::{DirectionalTiles, TileSequence},
|
||||
sprite::AtlasTile,
|
||||
},
|
||||
};
|
||||
use micromap::Map;
|
||||
|
||||
/// A tag component for entities that are controlled by the player.
|
||||
#[derive(Default, Component)]
|
||||
@@ -96,30 +100,46 @@ pub struct Renderable {
|
||||
pub layer: u8,
|
||||
}
|
||||
|
||||
/// A component for entities that have a directional animated texture.
|
||||
#[derive(Component, Clone, Default)]
|
||||
pub struct DirectionalAnimated {
|
||||
pub textures: [Option<AnimatedTexture>; 4],
|
||||
pub stopped_textures: [Option<AnimatedTexture>; 4],
|
||||
/// Directional animation component with shared timing across all directions
|
||||
#[derive(Component, Clone, Copy)]
|
||||
pub struct DirectionalAnimation {
|
||||
pub moving_tiles: DirectionalTiles,
|
||||
pub stopped_tiles: DirectionalTiles,
|
||||
pub current_frame: usize,
|
||||
pub time_bank: u16,
|
||||
pub frame_duration: u16,
|
||||
}
|
||||
|
||||
impl DirectionalAnimated {
|
||||
pub fn from_animation(animation: AnimatedTexture) -> Self {
|
||||
// Create 4 copies of the animation - necessary for independent state per direction
|
||||
// This is initialization-time only, so the cloning cost is acceptable
|
||||
impl DirectionalAnimation {
|
||||
/// Creates a new directional animation with the given tiles and frame duration
|
||||
pub fn new(moving_tiles: DirectionalTiles, stopped_tiles: DirectionalTiles, frame_duration: u16) -> Self {
|
||||
Self {
|
||||
textures: [
|
||||
Some(animation.clone()),
|
||||
Some(animation.clone()),
|
||||
Some(animation.clone()),
|
||||
Some(animation.clone()),
|
||||
],
|
||||
stopped_textures: [
|
||||
Some(animation.clone()),
|
||||
Some(animation.clone()),
|
||||
Some(animation.clone()),
|
||||
Some(animation),
|
||||
],
|
||||
moving_tiles,
|
||||
stopped_tiles,
|
||||
current_frame: 0,
|
||||
time_bank: 0,
|
||||
frame_duration,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Linear animation component for non-directional animations (frightened ghosts)
|
||||
#[derive(Component, Clone, Copy)]
|
||||
pub struct LinearAnimation {
|
||||
pub tiles: TileSequence,
|
||||
pub current_frame: usize,
|
||||
pub time_bank: u16,
|
||||
pub frame_duration: u16,
|
||||
}
|
||||
|
||||
impl LinearAnimation {
|
||||
/// Creates a new linear animation with the given tiles and frame duration
|
||||
pub fn new(tiles: TileSequence, frame_duration: u16) -> Self {
|
||||
Self {
|
||||
tiles,
|
||||
current_frame: 0,
|
||||
time_bank: 0,
|
||||
frame_duration,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -170,10 +190,75 @@ 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 {
|
||||
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.
|
||||
@@ -189,58 +274,6 @@ pub enum GhostAnimation {
|
||||
Eyes,
|
||||
}
|
||||
|
||||
/// 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>,
|
||||
}
|
||||
|
||||
impl GhostAnimationSet {
|
||||
/// Creates a new GhostAnimationSet with the provided animations.
|
||||
pub fn new(
|
||||
normal: DirectionalAnimated,
|
||||
frightened: DirectionalAnimated,
|
||||
frightened_flashing: DirectionalAnimated,
|
||||
eyes: DirectionalAnimated,
|
||||
) -> Self {
|
||||
let mut animations = Map::new();
|
||||
animations.insert(GhostAnimation::Normal, normal);
|
||||
animations.insert(GhostAnimation::Frightened { flash: false }, frightened);
|
||||
animations.insert(GhostAnimation::Frightened { flash: true }, frightened_flashing);
|
||||
animations.insert(GhostAnimation::Eyes, eyes);
|
||||
Self { animations }
|
||||
}
|
||||
|
||||
/// Gets the animation for the specified ghost animation state.
|
||||
pub fn get(&self, animation: GhostAnimation) -> Option<&DirectionalAnimated> {
|
||||
self.animations.get(&animation)
|
||||
}
|
||||
|
||||
/// Gets the normal animation state.
|
||||
pub fn normal(&self) -> Option<&DirectionalAnimated> {
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
/// Global resource containing pre-loaded animation sets for all ghost types.
|
||||
///
|
||||
/// This resource is initialized once during game startup and provides O(1) access
|
||||
@@ -248,9 +281,50 @@ impl GhostAnimationSet {
|
||||
/// to efficiently switch between different ghost states without runtime asset loading.
|
||||
///
|
||||
/// The HashMap is keyed by `Ghost` enum variants (Blinky, Pinky, Inky, Clyde) and
|
||||
/// contains complete animation sets mapped by GhostAnimation states.
|
||||
/// contains the normal directional animation for each ghost type.
|
||||
#[derive(Resource)]
|
||||
pub struct GhostAnimations(pub std::collections::HashMap<Ghost, GhostAnimationSet>);
|
||||
pub struct GhostAnimations {
|
||||
pub normal: HashMap<Ghost, DirectionalAnimation>,
|
||||
pub eyes: DirectionalAnimation,
|
||||
pub frightened: LinearAnimation,
|
||||
pub frightened_flashing: LinearAnimation,
|
||||
}
|
||||
|
||||
impl GhostAnimations {
|
||||
/// Creates a new GhostAnimations resource with the provided data.
|
||||
pub fn new(
|
||||
normal: HashMap<Ghost, DirectionalAnimation>,
|
||||
eyes: DirectionalAnimation,
|
||||
frightened: LinearAnimation,
|
||||
frightened_flashing: LinearAnimation,
|
||||
) -> Self {
|
||||
Self {
|
||||
normal,
|
||||
eyes,
|
||||
frightened,
|
||||
frightened_flashing,
|
||||
}
|
||||
}
|
||||
|
||||
/// Gets the normal directional animation for the specified ghost type.
|
||||
pub fn get_normal(&self, ghost_type: &Ghost) -> Option<&DirectionalAnimation> {
|
||||
self.normal.get(ghost_type)
|
||||
}
|
||||
|
||||
/// Gets the eyes animation (shared across all ghosts).
|
||||
pub fn eyes(&self) -> &DirectionalAnimation {
|
||||
&self.eyes
|
||||
}
|
||||
|
||||
/// Gets the frightened animations (shared across all ghosts).
|
||||
pub fn frightened(&self, flash: bool) -> &LinearAnimation {
|
||||
if flash {
|
||||
&self.frightened_flashing
|
||||
} else {
|
||||
&self.frightened
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Bundle)]
|
||||
pub struct PlayerBundle {
|
||||
@@ -259,7 +333,7 @@ pub struct PlayerBundle {
|
||||
pub velocity: Velocity,
|
||||
pub buffered_direction: BufferedDirection,
|
||||
pub sprite: Renderable,
|
||||
pub directional_animated: DirectionalAnimated,
|
||||
pub directional_animation: DirectionalAnimation,
|
||||
pub entity_type: EntityType,
|
||||
pub collider: Collider,
|
||||
pub movement_modifiers: MovementModifiers,
|
||||
@@ -281,8 +355,10 @@ pub struct GhostBundle {
|
||||
pub position: Position,
|
||||
pub velocity: Velocity,
|
||||
pub sprite: Renderable,
|
||||
pub directional_animated: DirectionalAnimated,
|
||||
pub directional_animation: DirectionalAnimation,
|
||||
pub entity_type: EntityType,
|
||||
pub collider: Collider,
|
||||
pub ghost_collider: GhostCollider,
|
||||
pub ghost_state: GhostState,
|
||||
pub last_animation_state: LastAnimationState,
|
||||
}
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use crate::systems::components::Frozen;
|
||||
use crate::systems::components::{DirectionalAnimation, Frozen, GhostAnimation, GhostState, LastAnimationState, LinearAnimation};
|
||||
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::{Commands, 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,41 @@ fn find_direction_to_target(
|
||||
|
||||
None
|
||||
}
|
||||
|
||||
/// Unified system that manages ghost state transitions and animations with component swapping
|
||||
pub fn ghost_state_system(
|
||||
mut commands: Commands,
|
||||
animations: Res<GhostAnimations>,
|
||||
mut ghosts: Query<(bevy_ecs::entity::Entity, &Ghost, &mut GhostState, &mut LastAnimationState)>,
|
||||
) {
|
||||
for (entity, ghost_type, mut ghost_state, 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 {
|
||||
match current_animation_state {
|
||||
GhostAnimation::Frightened { flash } => {
|
||||
// Remove DirectionalAnimation, add LinearAnimation
|
||||
commands
|
||||
.entity(entity)
|
||||
.remove::<DirectionalAnimation>()
|
||||
.insert(*animations.frightened(flash));
|
||||
}
|
||||
GhostAnimation::Normal => {
|
||||
// Remove LinearAnimation, add DirectionalAnimation
|
||||
commands
|
||||
.entity(entity)
|
||||
.remove::<LinearAnimation>()
|
||||
.insert(*animations.get_normal(ghost_type).unwrap());
|
||||
}
|
||||
GhostAnimation::Eyes => {
|
||||
// Remove LinearAnimation, add DirectionalAnimation (eyes animation)
|
||||
commands.entity(entity).remove::<LinearAnimation>().insert(*animations.eyes());
|
||||
}
|
||||
}
|
||||
last_animation_state.0 = current_animation_state;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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.
|
||||
@@ -27,7 +28,7 @@ pub fn item_system(
|
||||
mut score: ResMut<ScoreResource>,
|
||||
pacman_query: Query<Entity, With<PacmanCollider>>,
|
||||
item_query: Query<(Entity, &EntityType), With<ItemCollider>>,
|
||||
ghost_query: Query<Entity, With<GhostCollider>>,
|
||||
mut ghost_query: Query<&mut GhostState, With<GhostCollider>>,
|
||||
mut events: EventWriter<AudioEvent>,
|
||||
) {
|
||||
for event in collision_events.read() {
|
||||
@@ -54,16 +55,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
|
||||
for ghost_entity in ghost_query.iter() {
|
||||
commands.entity(ghost_entity).insert(Vulnerable {
|
||||
remaining_ticks: total_ticks,
|
||||
});
|
||||
// Set all ghosts to frightened state, except those in Eyes state
|
||||
for mut ghost_state in ghost_query.iter_mut() {
|
||||
if !matches!(*ghost_state, GhostState::Eyes) {
|
||||
*ghost_state = GhostState::new_frightened(total_ticks, FRIGHTENED_FLASH_START_TICKS);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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::*;
|
||||
|
||||
@@ -25,6 +25,7 @@ pub enum SystemId {
|
||||
Audio,
|
||||
Blinking,
|
||||
DirectionalRender,
|
||||
LinearRender,
|
||||
DirtyRender,
|
||||
HudRender,
|
||||
Render,
|
||||
|
||||
@@ -2,8 +2,8 @@ use crate::constants::CANVAS_SIZE;
|
||||
use crate::error::{GameError, TextureError};
|
||||
use crate::map::builder::Map;
|
||||
use crate::systems::{
|
||||
DebugState, DebugTextureResource, DeltaTime, DirectionalAnimated, Position, Renderable, ScoreResource, StartupSequence,
|
||||
Velocity,
|
||||
DebugState, DebugTextureResource, DeltaTime, DirectionalAnimation, LinearAnimation, Position, Renderable, ScoreResource,
|
||||
StartupSequence, Velocity,
|
||||
};
|
||||
use crate::texture::sprite::SpriteAtlas;
|
||||
use crate::texture::text::TextTexture;
|
||||
@@ -37,35 +37,64 @@ pub fn dirty_render_system(
|
||||
}
|
||||
}
|
||||
|
||||
/// Updates the directional animated texture of an entity.
|
||||
/// Updates directional animated entities with synchronized timing across directions.
|
||||
///
|
||||
/// This runs before the render system so it can update the sprite based on the current direction of travel, as well as whether the entity is moving.
|
||||
/// This runs before the render system to update sprites based on current direction and movement state.
|
||||
/// All directions share the same frame timing to ensure perfect synchronization.
|
||||
pub fn directional_render_system(
|
||||
dt: Res<DeltaTime>,
|
||||
mut renderables: Query<(&Position, &Velocity, &mut DirectionalAnimated, &mut Renderable)>,
|
||||
mut errors: EventWriter<GameError>,
|
||||
mut query: Query<(&Position, &Velocity, &mut DirectionalAnimation, &mut Renderable)>,
|
||||
) {
|
||||
for (position, velocity, mut texture, mut renderable) in renderables.iter_mut() {
|
||||
let stopped = matches!(position, Position::Stopped { .. });
|
||||
let current_direction = velocity.direction;
|
||||
let ticks = (dt.0 * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
|
||||
|
||||
let texture = if stopped {
|
||||
texture.stopped_textures[current_direction.as_usize()].as_mut()
|
||||
for (position, velocity, mut anim, mut renderable) in query.iter_mut() {
|
||||
let stopped = matches!(position, Position::Stopped { .. });
|
||||
|
||||
// Only tick animation when moving to preserve stopped frame
|
||||
if !stopped {
|
||||
// Tick shared animation state
|
||||
anim.time_bank += ticks;
|
||||
while anim.time_bank >= anim.frame_duration {
|
||||
anim.time_bank -= anim.frame_duration;
|
||||
anim.current_frame += 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Get tiles for current direction and movement state
|
||||
let tiles = if stopped {
|
||||
anim.stopped_tiles.get(velocity.direction)
|
||||
} else {
|
||||
texture.textures[current_direction.as_usize()].as_mut()
|
||||
anim.moving_tiles.get(velocity.direction)
|
||||
};
|
||||
|
||||
if let Some(texture) = texture {
|
||||
if !stopped {
|
||||
texture.tick(dt.0);
|
||||
}
|
||||
let new_tile = *texture.current_tile();
|
||||
if !tiles.is_empty() {
|
||||
let new_tile = tiles.get_tile(anim.current_frame);
|
||||
if renderable.sprite != new_tile {
|
||||
renderable.sprite = new_tile;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Updates linear animated entities (used for non-directional animations like frightened ghosts).
|
||||
///
|
||||
/// This system handles entities that use LinearAnimation component for simple frame cycling.
|
||||
pub fn linear_render_system(dt: Res<DeltaTime>, mut query: Query<(&mut LinearAnimation, &mut Renderable)>) {
|
||||
let ticks = (dt.0 * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
|
||||
|
||||
for (mut anim, mut renderable) in query.iter_mut() {
|
||||
// Tick animation
|
||||
anim.time_bank += ticks;
|
||||
while anim.time_bank >= anim.frame_duration {
|
||||
anim.time_bank -= anim.frame_duration;
|
||||
anim.current_frame += 1;
|
||||
}
|
||||
|
||||
if !anim.tiles.is_empty() {
|
||||
let new_tile = anim.tiles.get_tile(anim.current_frame);
|
||||
if renderable.sprite != new_tile {
|
||||
renderable.sprite = new_tile;
|
||||
}
|
||||
} else {
|
||||
errors.write(TextureError::RenderFailed("Entity has no texture".to_string()).into());
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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>();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,83 +1,73 @@
|
||||
use smallvec::SmallVec;
|
||||
|
||||
use crate::error::{AnimatedTextureError, GameError, GameResult, TextureError};
|
||||
use crate::map::direction::Direction;
|
||||
use crate::texture::sprite::AtlasTile;
|
||||
|
||||
/// Frame-based animation system for cycling through multiple sprite tiles.
|
||||
///
|
||||
/// Manages automatic frame progression based on elapsed time.
|
||||
/// Uses a time banking system to ensure consistent animation speed regardless of frame rate variations.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct AnimatedTexture {
|
||||
/// Sequence of sprite tiles that make up the animation frames
|
||||
tiles: SmallVec<[AtlasTile; 4]>,
|
||||
/// Duration each frame should be displayed (in seconds)
|
||||
frame_duration: f32,
|
||||
/// Index of the currently active frame in the tiles vector
|
||||
current_frame: usize,
|
||||
/// Accumulated time since the last frame change (for smooth timing)
|
||||
time_bank: f32,
|
||||
/// Fixed-size tile sequence that avoids heap allocation
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct TileSequence {
|
||||
tiles: [AtlasTile; 4], // Fixed array, max 4 frames
|
||||
count: usize, // Actual number of frames used
|
||||
}
|
||||
|
||||
impl AnimatedTexture {
|
||||
pub fn new(tiles: SmallVec<[AtlasTile; 4]>, frame_duration: f32) -> GameResult<Self> {
|
||||
if frame_duration <= 0.0 {
|
||||
return Err(GameError::Texture(TextureError::Animated(
|
||||
AnimatedTextureError::InvalidFrameDuration(frame_duration),
|
||||
)));
|
||||
}
|
||||
impl TileSequence {
|
||||
/// Creates a new tile sequence from a slice of tiles
|
||||
pub fn new(tiles: &[AtlasTile]) -> Self {
|
||||
let mut tile_array = [AtlasTile {
|
||||
pos: glam::U16Vec2::ZERO,
|
||||
size: glam::U16Vec2::ZERO,
|
||||
color: None,
|
||||
}; 4];
|
||||
|
||||
Ok(Self {
|
||||
tiles,
|
||||
frame_duration,
|
||||
current_frame: 0,
|
||||
time_bank: 0.0,
|
||||
})
|
||||
}
|
||||
let count = tiles.len().min(4);
|
||||
tile_array[..count].copy_from_slice(&tiles[..count]);
|
||||
|
||||
/// Advances the animation by the specified time delta with automatic frame cycling.
|
||||
///
|
||||
/// Accumulates time in the time bank and progresses through frames when enough
|
||||
/// time has elapsed. Supports frame rates independent of game frame rate by
|
||||
/// potentially advancing multiple frames in a single call if `dt` is large.
|
||||
/// Animation loops automatically when reaching the final frame.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `dt` - Time elapsed since the last tick (typically frame delta time)
|
||||
pub fn tick(&mut self, dt: f32) {
|
||||
self.time_bank += dt;
|
||||
while self.time_bank >= self.frame_duration {
|
||||
self.time_bank -= self.frame_duration;
|
||||
self.current_frame = (self.current_frame + 1) % self.tiles.len();
|
||||
Self {
|
||||
tiles: tile_array,
|
||||
count,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn current_tile(&self) -> &AtlasTile {
|
||||
&self.tiles[self.current_frame]
|
||||
/// Returns the tile at the given frame index, wrapping if necessary
|
||||
pub fn get_tile(&self, frame: usize) -> AtlasTile {
|
||||
if self.count == 0 {
|
||||
// Return a default empty tile if no tiles
|
||||
AtlasTile {
|
||||
pos: glam::U16Vec2::ZERO,
|
||||
size: glam::U16Vec2::ZERO,
|
||||
color: None,
|
||||
}
|
||||
} else {
|
||||
self.tiles[frame % self.count]
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the current frame index.
|
||||
#[allow(dead_code)]
|
||||
pub fn current_frame(&self) -> usize {
|
||||
self.current_frame
|
||||
}
|
||||
|
||||
/// Returns the time bank.
|
||||
#[allow(dead_code)]
|
||||
pub fn time_bank(&self) -> f32 {
|
||||
self.time_bank
|
||||
}
|
||||
|
||||
/// Returns the frame duration.
|
||||
#[allow(dead_code)]
|
||||
pub fn frame_duration(&self) -> f32 {
|
||||
self.frame_duration
|
||||
}
|
||||
|
||||
/// Returns the number of tiles in the animation.
|
||||
#[allow(dead_code)]
|
||||
pub fn tiles_len(&self) -> usize {
|
||||
self.tiles.len()
|
||||
/// Returns true if this sequence has no tiles
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.count == 0
|
||||
}
|
||||
}
|
||||
|
||||
/// Type-safe directional tile storage with named fields
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct DirectionalTiles {
|
||||
pub up: TileSequence,
|
||||
pub down: TileSequence,
|
||||
pub left: TileSequence,
|
||||
pub right: TileSequence,
|
||||
}
|
||||
|
||||
impl DirectionalTiles {
|
||||
/// Creates a new DirectionalTiles with different sequences per direction
|
||||
pub fn new(up: TileSequence, down: TileSequence, left: TileSequence, right: TileSequence) -> Self {
|
||||
Self { up, down, left, right }
|
||||
}
|
||||
|
||||
/// Gets the tile sequence for the given direction
|
||||
pub fn get(&self, direction: Direction) -> &TileSequence {
|
||||
match direction {
|
||||
Direction::Up => &self.up,
|
||||
Direction::Down => &self.down,
|
||||
Direction::Left => &self.left,
|
||||
Direction::Right => &self.right,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,63 +1,57 @@
|
||||
use glam::U16Vec2;
|
||||
use pacman::error::{AnimatedTextureError, GameError, TextureError};
|
||||
use pacman::texture::animated::AnimatedTexture;
|
||||
use pacman::texture::sprite::AtlasTile;
|
||||
use sdl2::pixels::Color;
|
||||
use smallvec::smallvec;
|
||||
// use glam::U16Vec2;
|
||||
// use pacman::error::{AnimatedTextureError, GameError, TextureError};
|
||||
// use pacman::texture::sprite::AtlasTile;
|
||||
// use sdl2::pixels::Color;
|
||||
// use smallvec::smallvec;
|
||||
|
||||
fn mock_atlas_tile(id: u32) -> AtlasTile {
|
||||
AtlasTile {
|
||||
pos: U16Vec2::new(0, 0),
|
||||
size: U16Vec2::new(16, 16),
|
||||
color: Some(Color::RGB(id as u8, 0, 0)),
|
||||
}
|
||||
}
|
||||
// fn mock_atlas_tile(id: u32) -> AtlasTile {
|
||||
// AtlasTile {
|
||||
// pos: U16Vec2::new(0, 0),
|
||||
// size: U16Vec2::new(16, 16),
|
||||
// color: Some(Color::RGB(id as u8, 0, 0)),
|
||||
// }
|
||||
// }
|
||||
|
||||
#[test]
|
||||
fn test_animated_texture_creation_errors() {
|
||||
let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2)];
|
||||
// #[test]
|
||||
// fn test_animated_texture_creation_errors() {
|
||||
// let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2)];
|
||||
|
||||
assert!(matches!(
|
||||
AnimatedTexture::new(tiles.clone(), 0.0).unwrap_err(),
|
||||
GameError::Texture(TextureError::Animated(AnimatedTextureError::InvalidFrameDuration(0.0)))
|
||||
));
|
||||
// assert!(matches!(
|
||||
// AnimatedTexture::new(tiles.clone(), 0).unwrap_err(),
|
||||
// GameError::Texture(TextureError::Animated(AnimatedTextureError::InvalidFrameDuration(0)))
|
||||
// ));
|
||||
// }
|
||||
|
||||
assert!(matches!(
|
||||
AnimatedTexture::new(tiles, -0.1).unwrap_err(),
|
||||
GameError::Texture(TextureError::Animated(AnimatedTextureError::InvalidFrameDuration(-0.1)))
|
||||
));
|
||||
}
|
||||
// #[test]
|
||||
// fn test_animated_texture_advancement() {
|
||||
// let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2), mock_atlas_tile(3)];
|
||||
// let mut texture = AnimatedTexture::new(tiles, 10).unwrap();
|
||||
|
||||
#[test]
|
||||
fn test_animated_texture_advancement() {
|
||||
let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2), mock_atlas_tile(3)];
|
||||
let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
|
||||
// assert_eq!(texture.current_frame(), 0);
|
||||
|
||||
assert_eq!(texture.current_frame(), 0);
|
||||
// texture.tick(25);
|
||||
// assert_eq!(texture.current_frame(), 2);
|
||||
// assert_eq!(texture.time_bank(), 5);
|
||||
// }
|
||||
|
||||
texture.tick(0.25);
|
||||
assert_eq!(texture.current_frame(), 2);
|
||||
assert!((texture.time_bank() - 0.05).abs() < 0.001);
|
||||
}
|
||||
// #[test]
|
||||
// fn test_animated_texture_wrap_around() {
|
||||
// let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2)];
|
||||
// let mut texture = AnimatedTexture::new(tiles, 10).unwrap();
|
||||
|
||||
#[test]
|
||||
fn test_animated_texture_wrap_around() {
|
||||
let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2)];
|
||||
let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
|
||||
// texture.tick(10);
|
||||
// assert_eq!(texture.current_frame(), 1);
|
||||
|
||||
texture.tick(0.1);
|
||||
assert_eq!(texture.current_frame(), 1);
|
||||
// texture.tick(10);
|
||||
// assert_eq!(texture.current_frame(), 0);
|
||||
// }
|
||||
|
||||
texture.tick(0.1);
|
||||
assert_eq!(texture.current_frame(), 0);
|
||||
}
|
||||
// #[test]
|
||||
// fn test_animated_texture_single_frame() {
|
||||
// let tiles = smallvec![mock_atlas_tile(1)];
|
||||
// let mut texture = AnimatedTexture::new(tiles, 10).unwrap();
|
||||
|
||||
#[test]
|
||||
fn test_animated_texture_single_frame() {
|
||||
let tiles = smallvec![mock_atlas_tile(1)];
|
||||
let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
|
||||
|
||||
texture.tick(0.1);
|
||||
assert_eq!(texture.current_frame(), 0);
|
||||
assert_eq!(texture.current_tile().color.unwrap().r, 1);
|
||||
}
|
||||
// texture.tick(10);
|
||||
// assert_eq!(texture.current_frame(), 0);
|
||||
// assert_eq!(texture.current_tile().color.unwrap().r, 1);
|
||||
// }
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
use pacman::error::{
|
||||
AnimatedTextureError, AssetError, EntityError, GameError, GameResult, IntoGameError, MapError, OptionExt, ParseError,
|
||||
ResultExt, TextureError,
|
||||
AssetError, EntityError, GameError, GameResult, IntoGameError, MapError, OptionExt, ParseError, ResultExt, TextureError,
|
||||
};
|
||||
use std::io;
|
||||
|
||||
@@ -46,13 +45,6 @@ fn test_game_error_from_io_error() {
|
||||
assert!(matches!(game_error, GameError::Io(_)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_texture_error_from_animated_error() {
|
||||
let animated_error = AnimatedTextureError::InvalidFrameDuration(-1.0);
|
||||
let texture_error: TextureError = animated_error.into();
|
||||
assert!(matches!(texture_error, TextureError::Animated(_)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_asset_error_from_io_error() {
|
||||
let io_error = io::Error::new(io::ErrorKind::PermissionDenied, "Permission denied");
|
||||
@@ -78,12 +70,6 @@ fn test_entity_error_display() {
|
||||
assert_eq!(error.to_string(), "Edge not found: from 1 to 2");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_animated_texture_error_display() {
|
||||
let error = AnimatedTextureError::InvalidFrameDuration(0.0);
|
||||
assert_eq!(error.to_string(), "Frame duration must be positive, got 0");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_into_game_error_trait() {
|
||||
let result: Result<i32, io::Error> = Err(io::Error::new(io::ErrorKind::Other, "test error"));
|
||||
@@ -146,13 +132,3 @@ fn test_result_ext_error() {
|
||||
panic!("Expected InvalidState error");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_error_chain_conversions() {
|
||||
// Test that we can convert through multiple levels
|
||||
let animated_error = AnimatedTextureError::InvalidFrameDuration(-5.0);
|
||||
let texture_error: TextureError = animated_error.into();
|
||||
let game_error: GameError = texture_error.into();
|
||||
|
||||
assert!(matches!(game_error, GameError::Texture(TextureError::Animated(_))));
|
||||
}
|
||||
|
||||
@@ -4,8 +4,8 @@ use pacman::{
|
||||
events::GameEvent,
|
||||
map::builder::Map,
|
||||
systems::{
|
||||
is_valid_item_collision, item_system, AudioEvent, AudioState, EntityType, ItemCollider, PacmanCollider, Position,
|
||||
ScoreResource,
|
||||
is_valid_item_collision, item_system, AudioEvent, AudioState, EntityType, Ghost, GhostCollider, GhostState, ItemCollider,
|
||||
PacmanCollider, Position, ScoreResource,
|
||||
},
|
||||
};
|
||||
|
||||
@@ -75,6 +75,18 @@ fn spawn_test_item(world: &mut World, item_type: EntityType) -> Entity {
|
||||
world.spawn((Position::Stopped { node: 1 }, item_type, ItemCollider)).id()
|
||||
}
|
||||
|
||||
fn spawn_test_ghost(world: &mut World, ghost_state: GhostState) -> Entity {
|
||||
world
|
||||
.spawn((
|
||||
Position::Stopped { node: 2 },
|
||||
Ghost::Blinky,
|
||||
EntityType::Ghost,
|
||||
GhostCollider,
|
||||
ghost_state,
|
||||
))
|
||||
.id()
|
||||
}
|
||||
|
||||
fn send_collision_event(world: &mut World, entity1: Entity, entity2: Entity) {
|
||||
let mut events = world.resource_mut::<Events<GameEvent>>();
|
||||
events.send(GameEvent::Collision(entity1, entity2));
|
||||
@@ -251,3 +263,40 @@ fn test_item_system_preserves_existing_score() {
|
||||
let score = world.resource::<ScoreResource>();
|
||||
assert_eq!(score.0, 110);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_power_pellet_does_not_affect_ghosts_in_eyes_state() {
|
||||
let mut world = create_test_world();
|
||||
let pacman = spawn_test_pacman(&mut world);
|
||||
let power_pellet = spawn_test_item(&mut world, EntityType::PowerPellet);
|
||||
|
||||
// Spawn a ghost in Eyes state (returning to ghost house)
|
||||
let eyes_ghost = spawn_test_ghost(&mut world, GhostState::Eyes);
|
||||
|
||||
// Spawn a ghost in Normal state
|
||||
let normal_ghost = spawn_test_ghost(&mut world, GhostState::Normal);
|
||||
|
||||
send_collision_event(&mut world, pacman, power_pellet);
|
||||
|
||||
world.run_system_once(item_system).expect("System should run successfully");
|
||||
|
||||
// Check that the power pellet was collected and score updated
|
||||
let score = world.resource::<ScoreResource>();
|
||||
assert_eq!(score.0, 50);
|
||||
|
||||
// Check that the power pellet was despawned
|
||||
let power_pellet_count = world
|
||||
.query::<&EntityType>()
|
||||
.iter(&world)
|
||||
.filter(|&entity_type| matches!(entity_type, EntityType::PowerPellet))
|
||||
.count();
|
||||
assert_eq!(power_pellet_count, 0);
|
||||
|
||||
// Check that the Eyes ghost state was not changed
|
||||
let eyes_ghost_state = world.entity(eyes_ghost).get::<GhostState>().unwrap();
|
||||
assert!(matches!(*eyes_ghost_state, GhostState::Eyes));
|
||||
|
||||
// Check that the Normal ghost state was changed to Frightened
|
||||
let normal_ghost_state = world.entity(normal_ghost).get::<GhostState>().unwrap();
|
||||
assert!(matches!(*normal_ghost_state, GhostState::Frightened { .. }));
|
||||
}
|
||||
|
||||
19
tests/tracing_buffer.rs
Normal file
19
tests/tracing_buffer.rs
Normal file
@@ -0,0 +1,19 @@
|
||||
use pacman::platform::tracing_buffer::SwitchableWriter;
|
||||
use std::io::Write;
|
||||
|
||||
#[test]
|
||||
fn test_switchable_writer_buffering() {
|
||||
let mut writer = SwitchableWriter::default();
|
||||
|
||||
// Write some data while in buffered mode
|
||||
writer.write_all(b"Hello, ").unwrap();
|
||||
writer.write_all(b"world!").unwrap();
|
||||
writer.write_all(b"This is buffered content.\n").unwrap();
|
||||
|
||||
// Switch to direct mode (this should flush to stdout and show buffer size)
|
||||
// In a real test we can't easily capture stdout, so we'll just verify it doesn't panic
|
||||
writer.switch_to_direct_mode().unwrap();
|
||||
|
||||
// Write more data in direct mode
|
||||
writer.write_all(b"Direct output after flush\n").unwrap();
|
||||
}
|
||||
Reference in New Issue
Block a user