mirror of
https://github.com/Xevion/Pac-Man.git
synced 2025-12-15 22:12:25 -06:00
refactor: remove all unused/broken tests, remove many now unused types/functions
This commit is contained in:
@@ -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]);
|
||||
}
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
use pacman::{
|
||||
asset::{get_asset_bytes, Asset},
|
||||
game::state::ATLAS_FRAMES,
|
||||
game::ATLAS_FRAMES,
|
||||
texture::sprite::{AtlasMapper, SpriteAtlas},
|
||||
};
|
||||
use sdl2::{
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
@@ -1,7 +1,6 @@
|
||||
use pacman::constants::RAW_BOARD;
|
||||
use pacman::map::builder::Map;
|
||||
|
||||
mod collision;
|
||||
mod item;
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
|
||||
@@ -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::<Vec<_>>();
|
||||
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::<Vec<_>>();
|
||||
// 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());
|
||||
// }
|
||||
|
||||
@@ -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::<usize, Texture<'static>>(0usize) };
|
||||
let atlas = SpriteAtlas::new(texture, mapper);
|
||||
// let mapper = AtlasMapper { frames };
|
||||
// let texture = unsafe { std::mem::transmute::<usize, Texture<'static>>(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()));
|
||||
// }
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user