diff --git a/src/app.rs b/src/app.rs index f796513..b81bd1e 100644 --- a/src/app.rs +++ b/src/app.rs @@ -17,7 +17,7 @@ pub struct App { pub game: Game, last_tick: Instant, focused: bool, - cursor_pos: Vec2, + _cursor_pos: Vec2, } impl App { @@ -46,7 +46,7 @@ impl App { .build() .map_err(|e| GameError::Sdl(e.to_string()))?; - let mut canvas = Box::leak(Box::new( + let canvas = Box::leak(Box::new( window .into_canvas() .accelerated() @@ -74,7 +74,7 @@ impl App { game, focused: true, last_tick: Instant::now(), - cursor_pos: Vec2::ZERO, + _cursor_pos: Vec2::ZERO, }) } diff --git a/src/entity/mod.rs b/src/entity/mod.rs index d23c3be..d05c62d 100644 --- a/src/entity/mod.rs +++ b/src/entity/mod.rs @@ -5,4 +5,3 @@ pub mod graph; pub mod item; pub mod pacman; pub mod r#trait; -pub mod traversal; diff --git a/src/entity/traversal.rs b/src/entity/traversal.rs deleted file mode 100644 index 1bec8a4..0000000 --- a/src/entity/traversal.rs +++ /dev/null @@ -1,159 +0,0 @@ -use crate::ecs::components::Position; -use crate::error::GameResult; - -use super::direction::Direction; -use super::graph::{Edge, Graph}; - -/// Manages an entity's movement through the graph. -/// -/// A `Traverser` encapsulates the state of an entity's position and direction, -/// providing a way to advance along the graph's paths based on a given distance. -/// It also handles direction changes, buffering the next intended direction. -pub struct Traverser { - /// The current position of the traverser in the graph. - pub position: Position, - /// The current direction of movement. - pub direction: Direction, - /// Buffered direction change with remaining frame count for timing. - /// - /// The `u8` value represents the number of frames remaining before - /// the buffered direction expires. This allows for responsive controls - /// by storing direction changes for a limited time. - pub next_direction: Option<(Direction, u8)>, -} - -impl Traverser { - /// Sets the next direction for the traverser to take. - /// - /// The direction is buffered and will be applied at the next opportunity, - /// typically when the traverser reaches a new node. This allows for responsive - /// controls, as the new direction is stored for a limited time. - pub fn set_next_direction(&mut self, new_direction: Direction) { - if self.direction != new_direction { - self.next_direction = Some((new_direction, 30)); - } - } - - /// Advances the traverser along the graph by a specified distance. - /// - /// This method updates the traverser's position based on its current state - /// and the distance to travel. - /// - /// - If at a node, it checks for a buffered direction to start moving. - /// - If between nodes, it moves along the current edge. - /// - If it reaches a node, it attempts to transition to a new edge based on - /// the buffered direction or by continuing straight. - /// - If no valid move is possible, it stops at the node. - /// - /// Returns an error if the movement is invalid (e.g., trying to move in an impossible direction). - pub fn advance(&mut self, graph: &Graph, distance: f32, can_traverse: &F) -> GameResult<()> - where - F: Fn(Edge) -> bool, - { - // Decrement the remaining frames for the next direction - if let Some((direction, remaining)) = self.next_direction { - if remaining > 0 { - self.next_direction = Some((direction, remaining - 1)); - } else { - self.next_direction = None; - } - } - - match self.position { - Position::AtNode(node_id) => { - // We're not moving, but a buffered direction is available. - if let Some((next_direction, _)) = self.next_direction { - if let Some(edge) = graph.find_edge_in_direction(node_id, next_direction) { - if can_traverse(edge) { - // Start moving in that direction - self.position = Position::BetweenNodes { - from: node_id, - to: edge.target, - traversed: distance.max(0.0), - }; - self.direction = next_direction; - } else { - return Err(crate::error::GameError::Entity(crate::error::EntityError::InvalidMovement( - format!( - "Cannot traverse edge from {} to {} in direction {:?}", - node_id, edge.target, next_direction - ), - ))); - } - } else { - return Err(crate::error::GameError::Entity(crate::error::EntityError::InvalidMovement( - format!("No edge found in direction {:?} from node {}", next_direction, node_id), - ))); - } - - self.next_direction = None; // Consume the buffered direction regardless of whether we started moving with it - } - } - Position::BetweenNodes { from, to, traversed } => { - // There is no point in any of the next logic if we don't travel at all - if distance <= 0.0 { - return Ok(()); - } - - let edge = graph.find_edge(from, to).ok_or_else(|| { - crate::error::GameError::Entity(crate::error::EntityError::InvalidMovement(format!( - "Inconsistent state: Traverser is on a non-existent edge from {} to {}.", - from, to - ))) - })?; - - let new_traversed = traversed + distance; - - if new_traversed < edge.distance { - // Still on the same edge, just update the distance. - self.position = Position::BetweenNodes { - from, - to, - traversed: new_traversed, - }; - } else { - let overflow = new_traversed - edge.distance; - let mut moved = false; - - // If we buffered a direction, try to find an edge in that direction - if let Some((next_dir, _)) = self.next_direction { - if let Some(edge) = graph.find_edge_in_direction(to, next_dir) { - if can_traverse(edge) { - self.position = Position::BetweenNodes { - from: to, - to: edge.target, - traversed: overflow, - }; - - self.direction = next_dir; // Remember our new direction - self.next_direction = None; // Consume the buffered direction - moved = true; - } - } - } - - // If we didn't move, try to continue in the current direction - if !moved { - if let Some(edge) = graph.find_edge_in_direction(to, self.direction) { - if can_traverse(edge) { - self.position = Position::BetweenNodes { - from: to, - to: edge.target, - traversed: overflow, - }; - } else { - self.position = Position::AtNode(to); - self.next_direction = None; - } - } else { - self.position = Position::AtNode(to); - self.next_direction = None; - } - } - } - } - } - - Ok(()) - } -} diff --git a/src/texture/animated.rs b/src/texture/animated.rs index 5bf5e7d..8020797 100644 --- a/src/texture/animated.rs +++ b/src/texture/animated.rs @@ -1,8 +1,5 @@ -use sdl2::rect::Rect; -use sdl2::render::{Canvas, RenderTarget}; - use crate::error::{AnimatedTextureError, GameError, GameResult, TextureError}; -use crate::texture::sprite::{AtlasTile, SpriteAtlas}; +use crate::texture::sprite::AtlasTile; #[derive(Debug, Clone)] pub struct AnimatedTexture { @@ -40,12 +37,6 @@ impl AnimatedTexture { &self.tiles[self.current_frame] } - pub fn render(&self, canvas: &mut Canvas, atlas: &mut SpriteAtlas, dest: Rect) -> GameResult<()> { - let mut tile = *self.current_tile(); - tile.render(canvas, atlas, dest)?; - Ok(()) - } - /// Returns the current frame index. #[allow(dead_code)] pub fn current_frame(&self) -> usize { diff --git a/src/texture/directional.rs b/src/texture/directional.rs deleted file mode 100644 index ab477c7..0000000 --- a/src/texture/directional.rs +++ /dev/null @@ -1,80 +0,0 @@ -use sdl2::rect::Rect; -use sdl2::render::{Canvas, RenderTarget}; - -use crate::entity::direction::Direction; -use crate::error::GameResult; -use crate::texture::animated::AnimatedTexture; -use crate::texture::sprite::SpriteAtlas; - -#[derive(Clone)] -pub struct DirectionalAnimatedTexture { - textures: [Option; 4], - stopped_textures: [Option; 4], -} - -impl DirectionalAnimatedTexture { - pub fn new(textures: [Option; 4], stopped_textures: [Option; 4]) -> Self { - Self { - textures, - stopped_textures, - } - } - - pub fn tick(&mut self, dt: f32) { - for texture in self.textures.iter_mut().flatten() { - texture.tick(dt); - } - } - - pub fn render( - &self, - canvas: &mut Canvas, - atlas: &mut SpriteAtlas, - dest: Rect, - direction: Direction, - ) -> GameResult<()> { - if let Some(texture) = &self.textures[direction.as_usize()] { - texture.render(canvas, atlas, dest) - } else { - Ok(()) - } - } - - pub fn render_stopped( - &self, - canvas: &mut Canvas, - atlas: &mut SpriteAtlas, - dest: Rect, - direction: Direction, - ) -> GameResult<()> { - if let Some(texture) = &self.stopped_textures[direction.as_usize()] { - texture.render(canvas, atlas, dest) - } else { - Ok(()) - } - } - - /// Returns true if the texture has a direction. - #[allow(dead_code)] - pub fn has_direction(&self, direction: Direction) -> bool { - self.textures[direction.as_usize()].is_some() - } - - /// Returns true if the texture has a stopped direction. - #[allow(dead_code)] - pub fn has_stopped_direction(&self, direction: Direction) -> bool { - self.stopped_textures[direction.as_usize()].is_some() - } - - /// Returns the number of textures. - #[allow(dead_code)] - pub fn texture_count(&self) -> usize { - self.textures.iter().filter(|t| t.is_some()).count() - } - - /// Returns the number of stopped textures. - #[allow(dead_code)] - pub fn stopped_texture_count(&self) -> usize { - self.stopped_textures.iter().filter(|t| t.is_some()).count() - } -} diff --git a/src/texture/mod.rs b/src/texture/mod.rs index 95aeee5..8d58c93 100644 --- a/src/texture/mod.rs +++ b/src/texture/mod.rs @@ -1,5 +1,4 @@ pub mod animated; pub mod blinking; -pub mod directional; pub mod sprite; pub mod text; diff --git a/src/texture/sprite.rs b/src/texture/sprite.rs index b271c9e..6e7111b 100644 --- a/src/texture/sprite.rs +++ b/src/texture/sprite.rs @@ -8,33 +8,6 @@ use std::collections::HashMap; use crate::error::TextureError; -/// A simple sprite for stationary items like pellets and energizers. -#[derive(Clone, Debug)] -pub struct Sprite { - pub atlas_tile: AtlasTile, -} - -impl Sprite { - pub fn new(atlas_tile: AtlasTile) -> Self { - Self { atlas_tile } - } - - pub fn render( - &self, - canvas: &mut Canvas, - atlas: &mut SpriteAtlas, - position: glam::Vec2, - ) -> Result<(), TextureError> { - let dest = crate::helpers::centered_with_size( - glam::IVec2::new(position.x as i32, position.y as i32), - glam::UVec2::new(self.atlas_tile.size.x as u32, self.atlas_tile.size.y as u32), - ); - let mut tile = self.atlas_tile; - tile.render(canvas, atlas, dest)?; - Ok(()) - } -} - #[derive(Clone, Debug, Deserialize)] pub struct AtlasMapper { pub frames: HashMap, diff --git a/tests/collision.rs b/tests/collision.rs deleted file mode 100644 index a7ea569..0000000 --- a/tests/collision.rs +++ /dev/null @@ -1,119 +0,0 @@ -use pacman::entity::collision::{Collidable, CollisionSystem}; -use pacman::entity::traversal::Position; - -struct MockCollidable { - pos: Position, -} - -impl Collidable for MockCollidable { - fn position(&self) -> Position { - self.pos - } -} - -#[test] -fn test_is_colliding_with() { - let entity1 = MockCollidable { - pos: Position::AtNode(1), - }; - let entity2 = MockCollidable { - pos: Position::AtNode(1), - }; - let entity3 = MockCollidable { - pos: Position::AtNode(2), - }; - let entity4 = MockCollidable { - pos: Position::BetweenNodes { - from: 1, - to: 2, - traversed: 0.5, - }, - }; - - assert!(entity1.is_colliding_with(&entity2)); - assert!(!entity1.is_colliding_with(&entity3)); - assert!(entity1.is_colliding_with(&entity4)); - assert!(entity3.is_colliding_with(&entity4)); -} - -#[test] -fn test_collision_system_register_and_query() { - let mut collision_system = CollisionSystem::default(); - - let pos1 = Position::AtNode(1); - let entity1 = collision_system.register_entity(pos1); - - let pos2 = Position::BetweenNodes { - from: 1, - to: 2, - traversed: 0.5, - }; - let entity2 = collision_system.register_entity(pos2); - - let pos3 = Position::AtNode(3); - let entity3 = collision_system.register_entity(pos3); - - // Test entities_at_node - assert_eq!(collision_system.entities_at_node(1), &[entity1, entity2]); - assert_eq!(collision_system.entities_at_node(2), &[entity2]); - assert_eq!(collision_system.entities_at_node(3), &[entity3]); - assert_eq!(collision_system.entities_at_node(4), &[] as &[u32]); - - // Test potential_collisions - let mut collisions1 = collision_system.potential_collisions(&pos1); - collisions1.sort_unstable(); - assert_eq!(collisions1, vec![entity1, entity2]); - - let mut collisions2 = collision_system.potential_collisions(&pos2); - collisions2.sort_unstable(); - assert_eq!(collisions2, vec![entity1, entity2]); - - let mut collisions3 = collision_system.potential_collisions(&pos3); - collisions3.sort_unstable(); - assert_eq!(collisions3, vec![entity3]); -} - -#[test] -fn test_collision_system_update() { - let mut collision_system = CollisionSystem::default(); - - let entity1 = collision_system.register_entity(Position::AtNode(1)); - - assert_eq!(collision_system.entities_at_node(1), &[entity1]); - assert_eq!(collision_system.entities_at_node(2), &[] as &[u32]); - - collision_system.update_position(entity1, Position::AtNode(2)); - - assert_eq!(collision_system.entities_at_node(1), &[] as &[u32]); - assert_eq!(collision_system.entities_at_node(2), &[entity1]); - - collision_system.update_position( - entity1, - Position::BetweenNodes { - from: 2, - to: 3, - traversed: 0.1, - }, - ); - - assert_eq!(collision_system.entities_at_node(1), &[] as &[u32]); - assert_eq!(collision_system.entities_at_node(2), &[entity1]); - assert_eq!(collision_system.entities_at_node(3), &[entity1]); -} - -#[test] -fn test_collision_system_remove() { - let mut collision_system = CollisionSystem::default(); - - let entity1 = collision_system.register_entity(Position::AtNode(1)); - let entity2 = collision_system.register_entity(Position::AtNode(1)); - - assert_eq!(collision_system.entities_at_node(1), &[entity1, entity2]); - - collision_system.remove_entity(entity1); - - assert_eq!(collision_system.entities_at_node(1), &[entity2]); - - collision_system.remove_entity(entity2); - assert_eq!(collision_system.entities_at_node(1), &[] as &[u32]); -} diff --git a/tests/common/mod.rs b/tests/common/mod.rs index 2cf25af..584bf56 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -2,7 +2,7 @@ use pacman::{ asset::{get_asset_bytes, Asset}, - game::state::ATLAS_FRAMES, + game::ATLAS_FRAMES, texture::sprite::{AtlasMapper, SpriteAtlas}, }; use sdl2::{ diff --git a/tests/directional.rs b/tests/directional.rs deleted file mode 100644 index 11b3707..0000000 --- a/tests/directional.rs +++ /dev/null @@ -1,77 +0,0 @@ -use glam::U16Vec2; -use pacman::entity::direction::Direction; -use pacman::texture::animated::AnimatedTexture; -use pacman::texture::directional::DirectionalAnimatedTexture; -use pacman::texture::sprite::AtlasTile; -use sdl2::pixels::Color; - -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_animated_texture(id: u32) -> AnimatedTexture { - AnimatedTexture::new(vec![mock_atlas_tile(id)], 0.1).expect("Invalid frame duration") -} - -#[test] -fn test_directional_texture_partial_directions() { - let mut textures = [None, None, None, None]; - textures[Direction::Up.as_usize()] = Some(mock_animated_texture(1)); - - let texture = DirectionalAnimatedTexture::new(textures, [None, None, None, None]); - - assert_eq!(texture.texture_count(), 1); - assert!(texture.has_direction(Direction::Up)); - assert!(!texture.has_direction(Direction::Down)); - assert!(!texture.has_direction(Direction::Left)); - assert!(!texture.has_direction(Direction::Right)); -} - -#[test] -fn test_directional_texture_all_directions() { - let mut textures = [None, None, None, None]; - let directions = [ - (Direction::Up, 1), - (Direction::Down, 2), - (Direction::Left, 3), - (Direction::Right, 4), - ]; - - for (direction, id) in directions { - textures[direction.as_usize()] = Some(mock_animated_texture(id)); - } - - let texture = DirectionalAnimatedTexture::new(textures, [None, None, None, None]); - - assert_eq!(texture.texture_count(), 4); - for direction in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] { - assert!(texture.has_direction(*direction)); - } -} - -#[test] -fn test_directional_texture_stopped() { - let mut stopped_textures = [None, None, None, None]; - stopped_textures[Direction::Up.as_usize()] = Some(mock_animated_texture(1)); - - let texture = DirectionalAnimatedTexture::new([None, None, None, None], stopped_textures); - - assert_eq!(texture.stopped_texture_count(), 1); - assert!(texture.has_stopped_direction(Direction::Up)); - assert!(!texture.has_stopped_direction(Direction::Down)); -} - -#[test] -fn test_directional_texture_tick() { - let mut textures = [None, None, None, None]; - textures[Direction::Up.as_usize()] = Some(mock_animated_texture(1)); - let mut texture = DirectionalAnimatedTexture::new(textures, [None, None, None, None]); - - // This is a bit of a placeholder, since we can't inspect the inner state easily. - // We're just ensuring the tick method runs without panicking. - texture.tick(0.1); -} diff --git a/tests/game.rs b/tests/game.rs index 6578d74..aa755fd 100644 --- a/tests/game.rs +++ b/tests/game.rs @@ -1,7 +1,6 @@ use pacman::constants::RAW_BOARD; use pacman::map::builder::Map; -mod collision; mod item; #[test] diff --git a/tests/ghost.rs b/tests/ghost.rs deleted file mode 100644 index 0798661..0000000 --- a/tests/ghost.rs +++ /dev/null @@ -1,48 +0,0 @@ -use pacman::entity::ghost::{Ghost, GhostType}; -use pacman::entity::graph::Graph; -use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas}; -use std::collections::HashMap; - -fn create_test_atlas() -> SpriteAtlas { - let mut frames = HashMap::new(); - let directions = ["up", "down", "left", "right"]; - let ghost_types = ["blinky", "pinky", "inky", "clyde"]; - - for ghost_type in &ghost_types { - for (i, dir) in directions.iter().enumerate() { - frames.insert( - format!("ghost/{}/{}_{}.png", ghost_type, dir, "a"), - MapperFrame { - x: i as u16 * 16, - y: 0, - width: 16, - height: 16, - }, - ); - frames.insert( - format!("ghost/{}/{}_{}.png", ghost_type, dir, "b"), - MapperFrame { - x: i as u16 * 16, - y: 16, - width: 16, - height: 16, - }, - ); - } - } - - let mapper = AtlasMapper { frames }; - let dummy_texture = unsafe { std::mem::zeroed() }; - SpriteAtlas::new(dummy_texture, mapper) -} - -#[test] -fn test_ghost_creation() { - let graph = Graph::new(); - let atlas = create_test_atlas(); - - let ghost = Ghost::new(&graph, 0, GhostType::Blinky, &atlas).unwrap(); - - assert_eq!(ghost.ghost_type, GhostType::Blinky); - assert_eq!(ghost.traverser.position.from_node_id(), 0); -} diff --git a/tests/graph.rs b/tests/graph.rs index 0653931..b9d4477 100644 --- a/tests/graph.rs +++ b/tests/graph.rs @@ -1,6 +1,5 @@ use pacman::entity::direction::Direction; use pacman::entity::graph::{EdgePermissions, Graph, Node}; -use pacman::entity::traversal::{Position, Traverser}; fn create_test_graph() -> Graph { let mut graph = Graph::new(); @@ -150,68 +149,3 @@ fn should_find_edge_between_nodes() { let non_existent_edge = graph.find_edge(0, 99); assert!(non_existent_edge.is_none()); } - -#[test] -fn test_traverser_basic() { - let graph = create_test_graph(); - let mut traverser = Traverser::new(&graph, 0, Direction::Left, &|_| true); - - traverser.set_next_direction(Direction::Up); - assert!(traverser.next_direction.is_some()); - assert_eq!(traverser.next_direction.unwrap().0, Direction::Up); -} - -#[test] -fn test_traverser_advance() { - let graph = create_test_graph(); - let mut traverser = Traverser::new(&graph, 0, Direction::Right, &|_| true); - - traverser.advance(&graph, 5.0, &|_| true).unwrap(); - - match traverser.position { - Position::BetweenNodes { from, to, traversed } => { - assert_eq!(from, 0); - assert_eq!(to, 1); - assert_eq!(traversed, 5.0); - } - _ => panic!("Expected to be between nodes"), - } - - traverser.advance(&graph, 3.0, &|_| true).unwrap(); - - match traverser.position { - Position::BetweenNodes { from, to, traversed } => { - assert_eq!(from, 0); - assert_eq!(to, 1); - assert_eq!(traversed, 8.0); - } - _ => panic!("Expected to be between nodes"), - } -} - -#[test] -fn test_traverser_with_permissions() { - let mut graph = Graph::new(); - let node1 = graph.add_node(Node { - position: glam::Vec2::new(0.0, 0.0), - }); - let node2 = graph.add_node(Node { - position: glam::Vec2::new(16.0, 0.0), - }); - - graph - .add_edge(node1, node2, false, None, Direction::Right, EdgePermissions::GhostsOnly) - .unwrap(); - - // Pacman can't traverse ghost-only edges - let mut traverser = Traverser::new(&graph, node1, Direction::Right, &|edge| { - matches!(edge.permissions, EdgePermissions::All) - }); - - traverser - .advance(&graph, 5.0, &|edge| matches!(edge.permissions, EdgePermissions::All)) - .unwrap(); - - // Should still be at the node since it can't traverse - assert!(traverser.position.is_at_node()); -} diff --git a/tests/item.rs b/tests/item.rs index 7a881f9..c8f5b99 100644 --- a/tests/item.rs +++ b/tests/item.rs @@ -1,53 +1,46 @@ -use glam::U16Vec2; -use pacman::{ - entity::{ - collision::Collidable, - item::{FruitKind, Item, ItemType}, - }, - texture::sprite::{AtlasTile, Sprite}, -}; -use strum::{EnumCount, IntoEnumIterator}; +// use glam::U16Vec2; +// use pacman::texture::sprite::{AtlasTile, Sprite}; -#[test] -fn test_item_type_get_score() { - assert_eq!(ItemType::Pellet.get_score(), 10); - assert_eq!(ItemType::Energizer.get_score(), 50); +// #[test] +// fn test_item_type_get_score() { +// assert_eq!(ItemType::Pellet.get_score(), 10); +// assert_eq!(ItemType::Energizer.get_score(), 50); - let fruit = ItemType::Fruit { kind: FruitKind::Apple }; - assert_eq!(fruit.get_score(), 100); -} +// let fruit = ItemType::Fruit { kind: FruitKind::Apple }; +// assert_eq!(fruit.get_score(), 100); +// } -#[test] -fn test_fruit_kind_increasing_score() { - // Build a list of fruit kinds, sorted by their index - let mut kinds = FruitKind::iter() - .map(|kind| (kind.index(), kind.get_score())) - .collect::>(); - kinds.sort_unstable_by_key(|(index, _)| *index); +// #[test] +// fn test_fruit_kind_increasing_score() { +// // Build a list of fruit kinds, sorted by their index +// let mut kinds = FruitKind::iter() +// .map(|kind| (kind.index(), kind.get_score())) +// .collect::>(); +// kinds.sort_unstable_by_key(|(index, _)| *index); - assert_eq!(kinds.len(), FruitKind::COUNT); +// assert_eq!(kinds.len(), FruitKind::COUNT); - // Check that the score increases as expected - for window in kinds.windows(2) { - let ((_, prev), (_, next)) = (window[0], window[1]); - assert!(prev < next, "Fruits should have increasing scores, but {prev:?} < {next:?}"); - } -} +// // Check that the score increases as expected +// for window in kinds.windows(2) { +// let ((_, prev), (_, next)) = (window[0], window[1]); +// assert!(prev < next, "Fruits should have increasing scores, but {prev:?} < {next:?}"); +// } +// } -#[test] -fn test_item_creation_and_collection() { - let atlas_tile = AtlasTile { - pos: U16Vec2::new(0, 0), - size: U16Vec2::new(16, 16), - color: None, - }; - let sprite = Sprite::new(atlas_tile); - let mut item = Item::new(0, ItemType::Pellet, sprite); +// #[test] +// fn test_item_creation_and_collection() { +// let atlas_tile = AtlasTile { +// pos: U16Vec2::new(0, 0), +// size: U16Vec2::new(16, 16), +// color: None, +// }; +// let sprite = Sprite::new(atlas_tile); +// let mut item = Item::new(0, ItemType::Pellet, sprite); - assert!(!item.is_collected()); - assert_eq!(item.get_score(), 10); - assert_eq!(item.position().from_node_id(), 0); +// assert!(!item.is_collected()); +// assert_eq!(item.get_score(), 10); +// assert_eq!(item.position().from_node_id(), 0); - item.collect(); - assert!(item.is_collected()); -} +// item.collect(); +// assert!(item.is_collected()); +// } diff --git a/tests/map_builder.rs b/tests/map_builder.rs index 5fb5df7..e67a17a 100644 --- a/tests/map_builder.rs +++ b/tests/map_builder.rs @@ -1,7 +1,6 @@ use glam::Vec2; use pacman::constants::{CELL_SIZE, RAW_BOARD}; use pacman::map::builder::Map; -use sdl2::render::Texture; #[test] fn test_map_creation() { @@ -34,60 +33,60 @@ fn test_map_node_positions() { } } -#[test] -fn test_generate_items() { - use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas}; - use std::collections::HashMap; +// #[test] +// fn test_generate_items() { +// use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas}; +// use std::collections::HashMap; - let map = Map::new(RAW_BOARD).unwrap(); +// let map = Map::new(RAW_BOARD).unwrap(); - // Create a minimal atlas for testing - let mut frames = HashMap::new(); - frames.insert( - "maze/pellet.png".to_string(), - MapperFrame { - x: 0, - y: 0, - width: 8, - height: 8, - }, - ); - frames.insert( - "maze/energizer.png".to_string(), - MapperFrame { - x: 8, - y: 0, - width: 8, - height: 8, - }, - ); +// // Create a minimal atlas for testing +// let mut frames = HashMap::new(); +// frames.insert( +// "maze/pellet.png".to_string(), +// MapperFrame { +// x: 0, +// y: 0, +// width: 8, +// height: 8, +// }, +// ); +// frames.insert( +// "maze/energizer.png".to_string(), +// MapperFrame { +// x: 8, +// y: 0, +// width: 8, +// height: 8, +// }, +// ); - let mapper = AtlasMapper { frames }; - let texture = unsafe { std::mem::transmute::>(0usize) }; - let atlas = SpriteAtlas::new(texture, mapper); +// let mapper = AtlasMapper { frames }; +// let texture = unsafe { std::mem::transmute::>(0usize) }; +// let atlas = SpriteAtlas::new(texture, mapper); - let items = map.generate_items(&atlas).unwrap(); +// let items = map.generate_items(&atlas).unwrap(); - // Verify we have items - assert!(!items.is_empty()); +// // Verify we have items +// assert!(!items.is_empty()); - // Count different types - let pellet_count = items - .iter() - .filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Pellet)) - .count(); - let energizer_count = items - .iter() - .filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Energizer)) - .count(); +// // Count different types +// let pellet_count = items +// .iter() +// .filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Pellet)) +// .count(); +// let energizer_count = items +// .iter() +// .filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Energizer)) +// .count(); - // Should have both types - assert_eq!(pellet_count, 240); - assert_eq!(energizer_count, 4); +// // Should have both types +// assert_eq!(pellet_count, 240); +// assert_eq!(energizer_count, 4); - // All items should be uncollected initially - assert!(items.iter().all(|item| !item.is_collected())); +// // All items should be uncollected initially +// assert!(items.iter().all(|item| !item.is_collected())); - // All items should have valid node indices - assert!(items.iter().all(|item| item.node_index < map.graph.node_count())); -} +// // All items should have valid node indices +// assert!(items.iter().all(|item| item.node_index < map.graph.node_count())); +// } diff --git a/tests/pacman.rs b/tests/pacman.rs deleted file mode 100644 index d591215..0000000 --- a/tests/pacman.rs +++ /dev/null @@ -1,73 +0,0 @@ -use pacman::entity::direction::Direction; -use pacman::entity::graph::{Graph, Node}; -use pacman::entity::pacman::Pacman; -use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas}; -use std::collections::HashMap; - -fn create_test_graph() -> Graph { - let mut graph = Graph::new(); - let node1 = graph.add_node(Node { - position: glam::Vec2::new(0.0, 0.0), - }); - let node2 = graph.add_node(Node { - position: glam::Vec2::new(16.0, 0.0), - }); - let node3 = graph.add_node(Node { - position: glam::Vec2::new(0.0, 16.0), - }); - - graph.connect(node1, node2, false, None, Direction::Right).unwrap(); - graph.connect(node1, node3, false, None, Direction::Down).unwrap(); - - graph -} - -fn create_test_atlas() -> SpriteAtlas { - let mut frames = HashMap::new(); - let directions = ["up", "down", "left", "right"]; - - for (i, dir) in directions.iter().enumerate() { - frames.insert( - format!("pacman/{dir}_a.png"), - MapperFrame { - x: i as u16 * 16, - y: 0, - width: 16, - height: 16, - }, - ); - frames.insert( - format!("pacman/{dir}_b.png"), - MapperFrame { - x: i as u16 * 16, - y: 16, - width: 16, - height: 16, - }, - ); - } - - frames.insert( - "pacman/full.png".to_string(), - MapperFrame { - x: 64, - y: 0, - width: 16, - height: 16, - }, - ); - - let mapper = AtlasMapper { frames }; - let dummy_texture = unsafe { std::mem::zeroed() }; - SpriteAtlas::new(dummy_texture, mapper) -} - -#[test] -fn test_pacman_creation() { - let graph = create_test_graph(); - let atlas = create_test_atlas(); - let pacman = Pacman::new(&graph, 0, &atlas).unwrap(); - - assert!(pacman.traverser.position.is_at_node()); - assert_eq!(pacman.traverser.direction, Direction::Left); -} diff --git a/tests/pathfinding.rs b/tests/pathfinding.rs deleted file mode 100644 index 030bd9a..0000000 --- a/tests/pathfinding.rs +++ /dev/null @@ -1,120 +0,0 @@ -use pacman::entity::direction::Direction; -use pacman::entity::ghost::{Ghost, GhostType}; -use pacman::entity::graph::{Graph, Node}; -use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas}; -use std::collections::HashMap; - -fn create_test_atlas() -> SpriteAtlas { - let mut frames = HashMap::new(); - let directions = ["up", "down", "left", "right"]; - let ghost_types = ["blinky", "pinky", "inky", "clyde"]; - - for ghost_type in &ghost_types { - for (i, dir) in directions.iter().enumerate() { - frames.insert( - format!("ghost/{}/{}_{}.png", ghost_type, dir, "a"), - MapperFrame { - x: i as u16 * 16, - y: 0, - width: 16, - height: 16, - }, - ); - frames.insert( - format!("ghost/{}/{}_{}.png", ghost_type, dir, "b"), - MapperFrame { - x: i as u16 * 16, - y: 16, - width: 16, - height: 16, - }, - ); - } - } - - let mapper = AtlasMapper { frames }; - let dummy_texture = unsafe { std::mem::zeroed() }; - SpriteAtlas::new(dummy_texture, mapper) -} - -#[test] -fn test_ghost_pathfinding() { - // Create a simple test graph - let mut graph = Graph::new(); - - // Add nodes in a simple line: 0 -> 1 -> 2 - let node0 = graph.add_node(Node { - position: glam::Vec2::new(0.0, 0.0), - }); - let node1 = graph.add_node(Node { - position: glam::Vec2::new(10.0, 0.0), - }); - let node2 = graph.add_node(Node { - position: glam::Vec2::new(20.0, 0.0), - }); - - // Connect the nodes - graph.connect(node0, node1, false, None, Direction::Right).unwrap(); - graph.connect(node1, node2, false, None, Direction::Right).unwrap(); - - // Create a test atlas for the ghost - let atlas = create_test_atlas(); - - // Create a ghost at node 0 - let ghost = Ghost::new(&graph, node0, GhostType::Blinky, &atlas).unwrap(); - - // Test pathfinding from node 0 to node 2 - let path = ghost.calculate_path_to_target(&graph, node2); - - assert!(path.is_ok()); - let path = path.unwrap(); - assert!( - path == vec![node0, node1, node2] || path == vec![node2, node1, node0], - "Path was not what was expected" - ); -} - -#[test] -fn test_ghost_pathfinding_no_path() { - // Create a test graph with disconnected components - let mut graph = Graph::new(); - - let node0 = graph.add_node(Node { - position: glam::Vec2::new(0.0, 0.0), - }); - let node1 = graph.add_node(Node { - position: glam::Vec2::new(10.0, 0.0), - }); - - // Don't connect the nodes - let atlas = create_test_atlas(); - let ghost = Ghost::new(&graph, node0, GhostType::Blinky, &atlas).unwrap(); - - // Test pathfinding when no path exists - let path = ghost.calculate_path_to_target(&graph, node1); - - assert!(path.is_err()); -} - -#[test] -fn test_ghost_debug_colors() { - let atlas = create_test_atlas(); - let mut graph = Graph::new(); - let node = graph.add_node(Node { - position: glam::Vec2::new(0.0, 0.0), - }); - - let blinky = Ghost::new(&graph, node, GhostType::Blinky, &atlas).unwrap(); - let pinky = Ghost::new(&graph, node, GhostType::Pinky, &atlas).unwrap(); - let inky = Ghost::new(&graph, node, GhostType::Inky, &atlas).unwrap(); - let clyde = Ghost::new(&graph, node, GhostType::Clyde, &atlas).unwrap(); - - // Test that each ghost has a different debug color - let colors = std::collections::HashSet::from([ - blinky.debug_color(), - pinky.debug_color(), - inky.debug_color(), - clyde.debug_color(), - ]); - assert_eq!(colors.len(), 4, "All ghost colors should be unique"); -} diff --git a/tests/sprite.rs b/tests/sprite.rs index 9da3510..74974ba 100644 --- a/tests/sprite.rs +++ b/tests/sprite.rs @@ -1,5 +1,5 @@ use glam::U16Vec2; -use pacman::texture::sprite::{AtlasMapper, AtlasTile, MapperFrame, Sprite, SpriteAtlas}; +use pacman::texture::sprite::{AtlasMapper, AtlasTile, MapperFrame, SpriteAtlas}; use sdl2::pixels::Color; use std::collections::HashMap; @@ -92,12 +92,3 @@ fn test_atlas_tile_new_and_with_color() { let tile_with_color = tile.with_color(color); assert_eq!(tile_with_color.color, Some(color)); } - -#[test] -fn test_sprite_new() { - let atlas_tile = AtlasTile::new(U16Vec2::new(0, 0), U16Vec2::new(16, 16), None); - let sprite = Sprite::new(atlas_tile); - - assert_eq!(sprite.atlas_tile.pos, atlas_tile.pos); - assert_eq!(sprite.atlas_tile.size, atlas_tile.size); -}