xevion/Pac-Man
1
0
Fork 0
mirror of https://github.com/Xevion/Pac-Man.git synced 2025-12-18 02:12:37 -06:00
Code Issues Packages Projects Releases Wiki Activity

refactor!: begin switching to bevy ECS, all tests broken, all systems broken

Browse Source
This commit is contained in:
Xevion
2025-08-14 15:06:56 -05:00
parent 2f1ff85d8f
commit bc759f1ed4
23 changed files with 2373 additions and 1414 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
src/entity/collision.rs
View File

@@ -1,128 +1,128 @@
use smallvec::SmallVec;
use std::collections::HashMap;
// use smallvec::SmallVec;
// use std::collections::HashMap;
use crate::entity::{graph::NodeId, traversal::Position};
// use crate::entity::{graph::NodeId, traversal::Position};
/// Trait for entities that can participate in collision detection.
pub trait Collidable {
/// Returns the current position of this entity.
fn position(&self) -> Position;
// /// Trait for entities that can participate in collision detection.
// pub trait Collidable {
// /// Returns the current position of this entity.
// fn position(&self) -> Position;
/// Checks if this entity is colliding with another entity.
#[allow(dead_code)]
fn is_colliding_with(&self, other: &dyn Collidable) -> bool {
positions_overlap(&self.position(), &other.position())
}
}
// /// Checks if this entity is colliding with another entity.
// #[allow(dead_code)]
// fn is_colliding_with(&self, other: &dyn Collidable) -> bool {
// positions_overlap(&self.position(), &other.position())
// }
// }
/// System for tracking entities by their positions for efficient collision detection.
#[derive(Default)]
pub struct CollisionSystem {
/// Maps node IDs to lists of entity IDs that are at that node
node_entities: HashMap<NodeId, Vec<EntityId>>,
/// Maps entity IDs to their current positions
entity_positions: HashMap<EntityId, Position>,
/// Next available entity ID
next_id: EntityId,
}
// /// System for tracking entities by their positions for efficient collision detection.
// #[derive(Default)]
// pub struct CollisionSystem {
// /// Maps node IDs to lists of entity IDs that are at that node
// node_entities: HashMap<NodeId, Vec<EntityId>>,
// /// Maps entity IDs to their current positions
// entity_positions: HashMap<EntityId, Position>,
// /// Next available entity ID
// next_id: EntityId,
// }
/// Unique identifier for an entity in the collision system
pub type EntityId = u32;
// /// Unique identifier for an entity in the collision system
// pub type EntityId = u32;
impl CollisionSystem {
/// Registers an entity with the collision system and returns its ID
pub fn register_entity(&mut self, position: Position) -> EntityId {
let id = self.next_id;
self.next_id += 1;
// impl CollisionSystem {
// /// Registers an entity with the collision system and returns its ID
// pub fn register_entity(&mut self, position: Position) -> EntityId {
// let id = self.next_id;
// self.next_id += 1;
self.entity_positions.insert(id, position);
self.update_node_entities(id, position);
// self.entity_positions.insert(id, position);
// self.update_node_entities(id, position);
id
}
// id
// }
/// Updates an entity's position
pub fn update_position(&mut self, entity_id: EntityId, new_position: Position) {
if let Some(old_position) = self.entity_positions.get(&entity_id) {
// Remove from old nodes
self.remove_from_nodes(entity_id, *old_position);
}
// /// Updates an entity's position
// pub fn update_position(&mut self, entity_id: EntityId, new_position: Position) {
// if let Some(old_position) = self.entity_positions.get(&entity_id) {
// // Remove from old nodes
// self.remove_from_nodes(entity_id, *old_position);
// }
// Update position and add to new nodes
self.entity_positions.insert(entity_id, new_position);
self.update_node_entities(entity_id, new_position);
}
// // Update position and add to new nodes
// self.entity_positions.insert(entity_id, new_position);
// self.update_node_entities(entity_id, new_position);
// }
/// Removes an entity from the collision system
#[allow(dead_code)]
pub fn remove_entity(&mut self, entity_id: EntityId) {
if let Some(position) = self.entity_positions.remove(&entity_id) {
self.remove_from_nodes(entity_id, position);
}
}
// /// Removes an entity from the collision system
// #[allow(dead_code)]
// pub fn remove_entity(&mut self, entity_id: EntityId) {
// if let Some(position) = self.entity_positions.remove(&entity_id) {
// self.remove_from_nodes(entity_id, position);
// }
// }
/// Gets all entity IDs at a specific node
pub fn entities_at_node(&self, node: NodeId) -> &[EntityId] {
self.node_entities.get(&node).map(|v| v.as_slice()).unwrap_or(&[])
}
// /// Gets all entity IDs at a specific node
// pub fn entities_at_node(&self, node: NodeId) -> &[EntityId] {
// self.node_entities.get(&node).map(|v| v.as_slice()).unwrap_or(&[])
// }
/// Gets all entity IDs that could collide with an entity at the given position
pub fn potential_collisions(&self, position: &Position) -> Vec<EntityId> {
let mut collisions = Vec::new();
let nodes = get_nodes(position);
// /// Gets all entity IDs that could collide with an entity at the given position
// pub fn potential_collisions(&self, position: &Position) -> Vec<EntityId> {
// let mut collisions = Vec::new();
// let nodes = get_nodes(position);
for node in nodes {
collisions.extend(self.entities_at_node(node));
}
// for node in nodes {
// collisions.extend(self.entities_at_node(node));
// }
// Remove duplicates
collisions.sort_unstable();
collisions.dedup();
collisions
}
// // Remove duplicates
// collisions.sort_unstable();
// collisions.dedup();
// collisions
// }
/// Updates the node_entities map when an entity's position changes
fn update_node_entities(&mut self, entity_id: EntityId, position: Position) {
let nodes = get_nodes(&position);
for node in nodes {
self.node_entities.entry(node).or_default().push(entity_id);
}
}
// /// Updates the node_entities map when an entity's position changes
// fn update_node_entities(&mut self, entity_id: EntityId, position: Position) {
// let nodes = get_nodes(&position);
// for node in nodes {
// self.node_entities.entry(node).or_default().push(entity_id);
// }
// }
/// Removes an entity from all nodes it was previously at
fn remove_from_nodes(&mut self, entity_id: EntityId, position: Position) {
let nodes = get_nodes(&position);
for node in nodes {
if let Some(entities) = self.node_entities.get_mut(&node) {
entities.retain(|&id| id != entity_id);
if entities.is_empty() {
self.node_entities.remove(&node);
}
}
}
}
}
// /// Removes an entity from all nodes it was previously at
// fn remove_from_nodes(&mut self, entity_id: EntityId, position: Position) {
// let nodes = get_nodes(&position);
// for node in nodes {
// if let Some(entities) = self.node_entities.get_mut(&node) {
// entities.retain(|&id| id != entity_id);
// if entities.is_empty() {
// self.node_entities.remove(&node);
// }
// }
// }
// }
// }
/// Checks if two positions overlap (entities are at the same location).
fn positions_overlap(a: &Position, b: &Position) -> bool {
let a_nodes = get_nodes(a);
let b_nodes = get_nodes(b);
// /// Checks if two positions overlap (entities are at the same location).
// fn positions_overlap(a: &Position, b: &Position) -> bool {
// let a_nodes = get_nodes(a);
// let b_nodes = get_nodes(b);
// Check if any nodes overlap
a_nodes.iter().any(|a_node| b_nodes.contains(a_node))
// // Check if any nodes overlap
// a_nodes.iter().any(|a_node| b_nodes.contains(a_node))
// TODO: More complex overlap detection, the above is a simple check, but it could become an early filter for more precise calculations later
}
// // TODO: More complex overlap detection, the above is a simple check, but it could become an early filter for more precise calculations later
// }
/// Gets all nodes that an entity is currently at or between.
fn get_nodes(pos: &Position) -> SmallVec<[NodeId; 2]> {
let mut nodes = SmallVec::new();
match pos {
Position::AtNode(node) => nodes.push(*node),
Position::BetweenNodes { from, to, .. } => {
nodes.push(*from);
nodes.push(*to);
}
}
nodes
}
// /// Gets all nodes that an entity is currently at or between.
// fn get_nodes(pos: &Position) -> SmallVec<[NodeId; 2]> {
// let mut nodes = SmallVec::new();
// match pos {
// Position::AtNode(node) => nodes.push(*node),
// Position::BetweenNodes { from, to, .. } => {
// nodes.push(*from);
// nodes.push(*to);
// }
// }
// nodes
// }

3
src/entity/direction.rs
View File

@@ -1,12 +1,13 @@
use glam::IVec2;
/// The four cardinal directions.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[repr(usize)]
pub enum Direction {
Up,
Down,
Left,
#[default]
Right,
}

448
src/entity/ghost.rs
View File

@@ -1,254 +1,254 @@
//! Ghost entity implementation.
//!
//! This module contains the ghost character logic, including movement,
//! animation, and rendering. Ghosts move through the game graph using
//! a traverser and display directional animated textures.
// //! Ghost entity implementation.
// //!
// //! This module contains the ghost character logic, including movement,
// //! animation, and rendering. Ghosts move through the game graph using
// //! a traverser and display directional animated textures.
use pathfinding::prelude::dijkstra;
use rand::prelude::*;
use smallvec::SmallVec;
use tracing::error;
// use pathfinding::prelude::dijkstra;
// use rand::prelude::*;
// use smallvec::SmallVec;
// use tracing::error;
use crate::entity::{
collision::Collidable,
direction::Direction,
graph::{Edge, EdgePermissions, Graph, NodeId},
r#trait::Entity,
traversal::Traverser,
};
use crate::texture::animated::AnimatedTexture;
use crate::texture::directional::DirectionalAnimatedTexture;
use crate::texture::sprite::SpriteAtlas;
// use crate::entity::{
// collision::Collidable,
// direction::Direction,
// graph::{Edge, EdgePermissions, Graph, NodeId},
// r#trait::Entity,
// traversal::Traverser,
// };
// use crate::texture::animated::AnimatedTexture;
// use crate::texture::directional::DirectionalAnimatedTexture;
// use crate::texture::sprite::SpriteAtlas;
use crate::error::{EntityError, GameError, GameResult, TextureError};
// use crate::error::{EntityError, GameError, GameResult, TextureError};
/// Determines if a ghost can traverse a given edge.
///
/// Ghosts can move through edges that allow all entities or ghost-only edges.
fn can_ghost_traverse(edge: Edge) -> bool {
matches!(edge.permissions, EdgePermissions::All | EdgePermissions::GhostsOnly)
}
// /// Determines if a ghost can traverse a given edge.
// ///
// /// Ghosts can move through edges that allow all entities or ghost-only edges.
// fn can_ghost_traverse(edge: Edge) -> bool {
// matches!(edge.permissions, EdgePermissions::All | EdgePermissions::GhostsOnly)
// }
/// The four classic ghost types.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GhostType {
Blinky,
Pinky,
Inky,
Clyde,
}
// /// The four classic ghost types.
// #[derive(Debug, Clone, Copy, PartialEq, Eq)]
// pub enum GhostType {
// Blinky,
// Pinky,
// Inky,
// Clyde,
// }
impl GhostType {
/// Returns the ghost type name for atlas lookups.
pub fn as_str(self) -> &'static str {
match self {
GhostType::Blinky => "blinky",
GhostType::Pinky => "pinky",
GhostType::Inky => "inky",
GhostType::Clyde => "clyde",
}
}
// impl GhostType {
// /// Returns the ghost type name for atlas lookups.
// pub fn as_str(self) -> &'static str {
// match self {
// GhostType::Blinky => "blinky",
// GhostType::Pinky => "pinky",
// GhostType::Inky => "inky",
// GhostType::Clyde => "clyde",
// }
// }
/// Returns the base movement speed for this ghost type.
pub fn base_speed(self) -> f32 {
match self {
GhostType::Blinky => 1.0,
GhostType::Pinky => 0.95,
GhostType::Inky => 0.9,
GhostType::Clyde => 0.85,
}
}
}
// /// Returns the base movement speed for this ghost type.
// pub fn base_speed(self) -> f32 {
// match self {
// GhostType::Blinky => 1.0,
// GhostType::Pinky => 0.95,
// GhostType::Inky => 0.9,
// GhostType::Clyde => 0.85,
// }
// }
// }
/// A ghost entity that roams the game world.
///
/// Ghosts move through the game world using a graph-based navigation system
/// and display directional animated sprites. They randomly choose directions
/// at each intersection.
pub struct Ghost {
/// Handles movement through the game graph
pub traverser: Traverser,
/// The type of ghost (affects appearance and speed)
pub ghost_type: GhostType,
/// Manages directional animated textures for different movement states
texture: DirectionalAnimatedTexture,
/// Current movement speed
speed: f32,
}
// /// A ghost entity that roams the game world.
// ///
// /// Ghosts move through the game world using a graph-based navigation system
// /// and display directional animated sprites. They randomly choose directions
// /// at each intersection.
// pub struct Ghost {
// /// Handles movement through the game graph
// pub traverser: Traverser,
// /// The type of ghost (affects appearance and speed)
// pub ghost_type: GhostType,
// /// Manages directional animated textures for different movement states
// texture: DirectionalAnimatedTexture,
// /// Current movement speed
// speed: f32,
// }
impl Entity for Ghost {
fn traverser(&self) -> &Traverser {
&self.traverser
}
// impl Entity for Ghost {
// fn traverser(&self) -> &Traverser {
// &self.traverser
// }
fn traverser_mut(&mut self) -> &mut Traverser {
&mut self.traverser
}
// fn traverser_mut(&mut self) -> &mut Traverser {
// &mut self.traverser
// }
fn texture(&self) -> &DirectionalAnimatedTexture {
&self.texture
}
// fn texture(&self) -> &DirectionalAnimatedTexture {
// &self.texture
// }
fn texture_mut(&mut self) -> &mut DirectionalAnimatedTexture {
&mut self.texture
}
// fn texture_mut(&mut self) -> &mut DirectionalAnimatedTexture {
// &mut self.texture
// }
fn speed(&self) -> f32 {
self.speed
}
// fn speed(&self) -> f32 {
// self.speed
// }
fn can_traverse(&self, edge: Edge) -> bool {
can_ghost_traverse(edge)
}
// fn can_traverse(&self, edge: Edge) -> bool {
// can_ghost_traverse(edge)
// }
fn tick(&mut self, dt: f32, graph: &Graph) {
// Choose random direction when at a node
if self.traverser.position.is_at_node() {
self.choose_random_direction(graph);
}
// fn tick(&mut self, dt: f32, graph: &Graph) {
// // Choose random direction when at a node
// if self.traverser.position.is_at_node() {
// self.choose_random_direction(graph);
// }
if let Err(e) = self.traverser.advance(graph, dt * 60.0 * self.speed, &can_ghost_traverse) {
error!("Ghost movement error: {}", e);
}
self.texture.tick(dt);
}
}
// if let Err(e) = self.traverser.advance(graph, dt * 60.0 * self.speed, &can_ghost_traverse) {
// error!("Ghost movement error: {}", e);
// }
// self.texture.tick(dt);
// }
// }
impl Ghost {
/// Creates a new ghost instance at the specified starting node.
///
/// Sets up animated textures for all four directions with moving and stopped states.
/// The moving animation cycles through two sprite variants.
pub fn new(graph: &Graph, start_node: NodeId, ghost_type: GhostType, atlas: &SpriteAtlas) -> GameResult<Self> {
let mut textures = [None, None, None, None];
let mut stopped_textures = [None, None, None, None];
// impl Ghost {
// /// Creates a new ghost instance at the specified starting node.
// ///
// /// Sets up animated textures for all four directions with moving and stopped states.
// /// The moving animation cycles through two sprite variants.
// pub fn new(graph: &Graph, start_node: NodeId, ghost_type: GhostType, atlas: &SpriteAtlas) -> GameResult<Self> {
// 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 => "up",
Direction::Down => "down",
Direction::Left => "left",
Direction::Right => "right",
};
let moving_tiles = vec![
SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"))
.ok_or_else(|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/{}_{}.png",
ghost_type.as_str(),
moving_prefix,
"a"
)))
})?,
SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "b"))
.ok_or_else(|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/{}_{}.png",
ghost_type.as_str(),
moving_prefix,
"b"
)))
})?,
];
// for direction in Direction::DIRECTIONS {
// let moving_prefix = match direction {
// Direction::Up => "up",
// Direction::Down => "down",
// Direction::Left => "left",
// Direction::Right => "right",
// };
// let moving_tiles = vec![
// SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"))
// .ok_or_else(|| {
// GameError::Texture(TextureError::AtlasTileNotFound(format!(
// "ghost/{}/{}_{}.png",
// ghost_type.as_str(),
// moving_prefix,
// "a"
// )))
// })?,
// SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "b"))
// .ok_or_else(|| {
// GameError::Texture(TextureError::AtlasTileNotFound(format!(
// "ghost/{}/{}_{}.png",
// ghost_type.as_str(),
// moving_prefix,
// "b"
// )))
// })?,
// ];
let stopped_tiles =
vec![
SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"))
.ok_or_else(|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/{}_{}.png",
ghost_type.as_str(),
moving_prefix,
"a"
)))
})?,
];
// let stopped_tiles =
// vec![
// SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"))
// .ok_or_else(|| {
// GameError::Texture(TextureError::AtlasTileNotFound(format!(
// "ghost/{}/{}_{}.png",
// ghost_type.as_str(),
// moving_prefix,
// "a"
// )))
// })?,
// ];
textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.2)?);
stopped_textures[direction.as_usize()] = Some(AnimatedTexture::new(stopped_tiles, 0.1)?);
}
// textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.2)?);
// stopped_textures[direction.as_usize()] = Some(AnimatedTexture::new(stopped_tiles, 0.1)?);
// }
Ok(Self {
traverser: Traverser::new(graph, start_node, Direction::Left, &can_ghost_traverse),
ghost_type,
texture: DirectionalAnimatedTexture::new(textures, stopped_textures),
speed: ghost_type.base_speed(),
})
}
// Ok(Self {
// traverser: Traverser::new(graph, start_node, Direction::Left, &can_ghost_traverse),
// ghost_type,
// texture: DirectionalAnimatedTexture::new(textures, stopped_textures),
// speed: ghost_type.base_speed(),
// })
// }
/// Chooses a random available direction at the current intersection.
fn choose_random_direction(&mut self, graph: &Graph) {
let current_node = self.traverser.position.from_node_id();
let intersection = &graph.adjacency_list[current_node];
// /// Chooses a random available direction at the current intersection.
// fn choose_random_direction(&mut self, graph: &Graph) {
// let current_node = self.traverser.position.from_node_id();
// let intersection = &graph.adjacency_list[current_node];
// Collect all available directions
let mut available_directions = SmallVec::<[_; 4]>::new();
for direction in Direction::DIRECTIONS {
if let Some(edge) = intersection.get(direction) {
if can_ghost_traverse(edge) {
available_directions.push(direction);
}
}
}
// Choose a random direction (avoid reversing unless necessary)
if !available_directions.is_empty() {
let mut rng = SmallRng::from_os_rng();
// // Collect all available directions
// let mut available_directions = SmallVec::<[_; 4]>::new();
// for direction in Direction::DIRECTIONS {
// if let Some(edge) = intersection.get(direction) {
// if can_ghost_traverse(edge) {
// available_directions.push(direction);
// }
// }
// }
// // Choose a random direction (avoid reversing unless necessary)
// if !available_directions.is_empty() {
// let mut rng = SmallRng::from_os_rng();
// Filter out the opposite direction if possible, but allow it if we have limited options
let opposite = self.traverser.direction.opposite();
let filtered_directions: Vec<_> = available_directions
.iter()
.filter(|&&dir| dir != opposite || available_directions.len() <= 2)
.collect();
// // Filter out the opposite direction if possible, but allow it if we have limited options
// let opposite = self.traverser.direction.opposite();
// let filtered_directions: Vec<_> = available_directions
// .iter()
// .filter(|&&dir| dir != opposite || available_directions.len() <= 2)
// .collect();
if let Some(&random_direction) = filtered_directions.choose(&mut rng) {
self.traverser.set_next_direction(*random_direction);
}
}
}
// if let Some(&random_direction) = filtered_directions.choose(&mut rng) {
// self.traverser.set_next_direction(*random_direction);
// }
// }
// }
/// Calculates the shortest path from the ghost's current position to a target node using Dijkstra's algorithm.
///
/// Returns a vector of NodeIds representing the path, or an error if pathfinding fails.
/// The path includes the current node and the target node.
pub fn calculate_path_to_target(&self, graph: &Graph, target: NodeId) -> GameResult<Vec<NodeId>> {
let start_node = self.traverser.position.from_node_id();
// /// Calculates the shortest path from the ghost's current position to a target node using Dijkstra's algorithm.
// ///
// /// Returns a vector of NodeIds representing the path, or an error if pathfinding fails.
// /// The path includes the current node and the target node.
// pub fn calculate_path_to_target(&self, graph: &Graph, target: NodeId) -> GameResult<Vec<NodeId>> {
// let start_node = self.traverser.position.from_node_id();
// Use Dijkstra's algorithm to find the shortest path
let result = dijkstra(
&start_node,
|&node_id| {
// Get all edges from the current node
graph.adjacency_list[node_id]
.edges()
.filter(|edge| can_ghost_traverse(*edge))
.map(|edge| (edge.target, (edge.distance * 100.0) as u32))
.collect::<Vec<_>>()
},
|&node_id| node_id == target,
);
// // Use Dijkstra's algorithm to find the shortest path
// let result = dijkstra(
// &start_node,
// |&node_id| {
// // Get all edges from the current node
// graph.adjacency_list[node_id]
// .edges()
// .filter(|edge| can_ghost_traverse(*edge))
// .map(|edge| (edge.target, (edge.distance * 100.0) as u32))
// .collect::<Vec<_>>()
// },
// |&node_id| node_id == target,
// );
result.map(|(path, _cost)| path).ok_or_else(|| {
GameError::Entity(EntityError::PathfindingFailed(format!(
"No path found from node {} to target {}",
start_node, target
)))
})
}
// result.map(|(path, _cost)| path).ok_or_else(|| {
// GameError::Entity(EntityError::PathfindingFailed(format!(
// "No path found from node {} to target {}",
// start_node, target
// )))
// })
// }
/// Returns the ghost's color for debug rendering.
pub fn debug_color(&self) -> sdl2::pixels::Color {
match self.ghost_type {
GhostType::Blinky => sdl2::pixels::Color::RGB(255, 0, 0), // Red
GhostType::Pinky => sdl2::pixels::Color::RGB(255, 182, 255), // Pink
GhostType::Inky => sdl2::pixels::Color::RGB(0, 255, 255), // Cyan
GhostType::Clyde => sdl2::pixels::Color::RGB(255, 182, 85), // Orange
}
}
}
// /// Returns the ghost's color for debug rendering.
// pub fn debug_color(&self) -> sdl2::pixels::Color {
// match self.ghost_type {
// GhostType::Blinky => sdl2::pixels::Color::RGB(255, 0, 0), // Red
// GhostType::Pinky => sdl2::pixels::Color::RGB(255, 182, 255), // Pink
// GhostType::Inky => sdl2::pixels::Color::RGB(0, 255, 255), // Cyan
// GhostType::Clyde => sdl2::pixels::Color::RGB(255, 182, 85), // Orange
// }
// }
// }
impl Collidable for Ghost {
fn position(&self) -> crate::entity::traversal::Position {
self.traverser.position
}
}
// impl Collidable for Ghost {
// fn position(&self) -> crate::entity::traversal::Position {
// self.traverser.position
// }
// }

5
src/entity/graph.rs
View File

@@ -1,9 +1,8 @@
use glam::Vec2;
use super::direction::Direction;
use crate::ecs::NodeId;
/// A unique identifier for a node, represented by its index in the graph's storage.
pub type NodeId = usize;
use super::direction::Direction;
/// Defines who can traverse a given edge.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]

206
src/entity/item.rs
View File

@@ -1,117 +1,117 @@
use crate::{
constants,
entity::{collision::Collidable, graph::Graph},
error::{EntityError, GameResult},
texture::sprite::{Sprite, SpriteAtlas},
};
use sdl2::render::{Canvas, RenderTarget};
use strum_macros::{EnumCount, EnumIter};
// use crate::{
// constants,
// entity::{collision::Collidable, graph::Graph},
// error::{EntityError, GameResult},
// texture::sprite::{Sprite, SpriteAtlas},
// };
// use sdl2::render::{Canvas, RenderTarget};
// use strum_macros::{EnumCount, EnumIter};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ItemType {
Pellet,
Energizer,
#[allow(dead_code)]
Fruit {
kind: FruitKind,
},
}
// #[derive(Debug, Clone, Copy, PartialEq, Eq)]
// pub enum ItemType {
// Pellet,
// Energizer,
// #[allow(dead_code)]
// Fruit {
// kind: FruitKind,
// },
// }
impl ItemType {
pub fn get_score(self) -> u32 {
match self {
ItemType::Pellet => 10,
ItemType::Energizer => 50,
ItemType::Fruit { kind } => kind.get_score(),
}
}
}
// impl ItemType {
// pub fn get_score(self) -> u32 {
// match self {
// ItemType::Pellet => 10,
// ItemType::Energizer => 50,
// ItemType::Fruit { kind } => kind.get_score(),
// }
// }
// }
#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, EnumCount)]
#[allow(dead_code)]
pub enum FruitKind {
Apple,
Strawberry,
Orange,
Melon,
Bell,
Key,
Galaxian,
}
// #[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, EnumCount)]
// #[allow(dead_code)]
// pub enum FruitKind {
// Apple,
// Strawberry,
// Orange,
// Melon,
// Bell,
// Key,
// Galaxian,
// }
impl FruitKind {
#[allow(dead_code)]
pub fn index(self) -> u8 {
match self {
FruitKind::Apple => 0,
FruitKind::Strawberry => 1,
FruitKind::Orange => 2,
FruitKind::Melon => 3,
FruitKind::Bell => 4,
FruitKind::Key => 5,
FruitKind::Galaxian => 6,
}
}
// impl FruitKind {
// #[allow(dead_code)]
// pub fn index(self) -> u8 {
// match self {
// FruitKind::Apple => 0,
// FruitKind::Strawberry => 1,
// FruitKind::Orange => 2,
// FruitKind::Melon => 3,
// FruitKind::Bell => 4,
// FruitKind::Key => 5,
// FruitKind::Galaxian => 6,
// }
// }
pub fn get_score(self) -> u32 {
match self {
FruitKind::Apple => 100,
FruitKind::Strawberry => 300,
FruitKind::Orange => 500,
FruitKind::Melon => 700,
FruitKind::Bell => 1000,
FruitKind::Key => 2000,
FruitKind::Galaxian => 3000,
}
}
}
// pub fn get_score(self) -> u32 {
// match self {
// FruitKind::Apple => 100,
// FruitKind::Strawberry => 300,
// FruitKind::Orange => 500,
// FruitKind::Melon => 700,
// FruitKind::Bell => 1000,
// FruitKind::Key => 2000,
// FruitKind::Galaxian => 3000,
// }
// }
// }
pub struct Item {
pub node_index: usize,
pub item_type: ItemType,
pub sprite: Sprite,
pub collected: bool,
}
// pub struct Item {
// pub node_index: usize,
// pub item_type: ItemType,
// pub sprite: Sprite,
// pub collected: bool,
// }
impl Item {
pub fn new(node_index: usize, item_type: ItemType, sprite: Sprite) -> Self {
Self {
node_index,
item_type,
sprite,
collected: false,
}
}
// impl Item {
// pub fn new(node_index: usize, item_type: ItemType, sprite: Sprite) -> Self {
// Self {
// node_index,
// item_type,
// sprite,
// collected: false,
// }
// }
pub fn is_collected(&self) -> bool {
self.collected
}
// pub fn is_collected(&self) -> bool {
// self.collected
// }
pub fn collect(&mut self) {
self.collected = true;
}
// pub fn collect(&mut self) {
// self.collected = true;
// }
pub fn get_score(&self) -> u32 {
self.item_type.get_score()
}
// pub fn get_score(&self) -> u32 {
// self.item_type.get_score()
// }
pub fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, graph: &Graph) -> GameResult<()> {
if self.collected {
return Ok(());
}
// pub fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, graph: &Graph) -> GameResult<()> {
// if self.collected {
// return Ok(());
// }
let node = graph
.get_node(self.node_index)
.ok_or(EntityError::NodeNotFound(self.node_index))?;
let position = node.position + constants::BOARD_PIXEL_OFFSET.as_vec2();
// let node = graph
// .get_node(self.node_index)
// .ok_or(EntityError::NodeNotFound(self.node_index))?;
// let position = node.position + constants::BOARD_PIXEL_OFFSET.as_vec2();
self.sprite.render(canvas, atlas, position)?;
Ok(())
}
}
// self.sprite.render(canvas, atlas, position)?;
// Ok(())
// }
// }
impl Collidable for Item {
fn position(&self) -> crate::entity::traversal::Position {
crate::entity::traversal::Position::AtNode(self.node_index)
}
}
// impl Collidable for Item {
// fn position(&self) -> crate::entity::traversal::Position {
// crate::entity::traversal::Position::AtNode(self.node_index)
// }
// }

196
src/entity/pacman.rs
View File

@@ -1,115 +1,115 @@
//! Pac-Man entity implementation.
//!
//! This module contains the main player character logic, including movement,
//! animation, and rendering. Pac-Man moves through the game graph using
//! a traverser and displays directional animated textures.
// //! Pac-Man entity implementation.
// //!
// //! This module contains the main player character logic, including movement,
// //! animation, and rendering. Pac-Man moves through the game graph using
// //! a traverser and displays directional animated textures.
use crate::entity::{
collision::Collidable,
direction::Direction,
graph::{Edge, EdgePermissions, Graph, NodeId},
r#trait::Entity,
traversal::Traverser,
};
use crate::texture::animated::AnimatedTexture;
use crate::texture::directional::DirectionalAnimatedTexture;
use crate::texture::sprite::SpriteAtlas;
use tracing::error;
// use crate::entity::{
// collision::Collidable,
// direction::Direction,
// graph::{Edge, EdgePermissions, Graph, NodeId},
// r#trait::Entity,
// traversal::Traverser,
// };
// use crate::texture::animated::AnimatedTexture;
// use crate::texture::directional::DirectionalAnimatedTexture;
// use crate::texture::sprite::SpriteAtlas;
// use tracing::error;
use crate::error::{GameError, GameResult, TextureError};
// use crate::error::{GameError, GameResult, TextureError};
/// Determines if Pac-Man can traverse a given edge.
///
/// Pac-Man can only move through edges that allow all entities.
fn can_pacman_traverse(edge: Edge) -> bool {
matches!(edge.permissions, EdgePermissions::All)
}
// /// Determines if Pac-Man can traverse a given edge.
// ///
// /// Pac-Man can only move through edges that allow all entities.
// fn can_pacman_traverse(edge: Edge) -> bool {
// matches!(edge.permissions, EdgePermissions::All)
// }
/// The main player character entity.
///
/// Pac-Man moves through the game world using a graph-based navigation system
/// and displays directional animated sprites based on movement state.
pub struct Pacman {
/// Handles movement through the game graph
pub traverser: Traverser,
/// Manages directional animated textures for different movement states
texture: DirectionalAnimatedTexture,
}
// /// The main player character entity.
// ///
// /// Pac-Man moves through the game world using a graph-based navigation system
// /// and displays directional animated sprites based on movement state.
// pub struct Pacman {
// /// Handles movement through the game graph
// pub traverser: Traverser,
// /// Manages directional animated textures for different movement states
// texture: DirectionalAnimatedTexture,
// }
impl Entity for Pacman {
fn traverser(&self) -> &Traverser {
&self.traverser
}
// impl Entity for Pacman {
// fn traverser(&self) -> &Traverser {
// &self.traverser
// }
fn traverser_mut(&mut self) -> &mut Traverser {
&mut self.traverser
}
// fn traverser_mut(&mut self) -> &mut Traverser {
// &mut self.traverser
// }
fn texture(&self) -> &DirectionalAnimatedTexture {
&self.texture
}
// fn texture(&self) -> &DirectionalAnimatedTexture {
// &self.texture
// }
fn texture_mut(&mut self) -> &mut DirectionalAnimatedTexture {
&mut self.texture
}
// fn texture_mut(&mut self) -> &mut DirectionalAnimatedTexture {
// &mut self.texture
// }
fn speed(&self) -> f32 {
1.125
}
// fn speed(&self) -> f32 {
// 1.125
// }
fn can_traverse(&self, edge: Edge) -> bool {
can_pacman_traverse(edge)
}
// fn can_traverse(&self, edge: Edge) -> bool {
// can_pacman_traverse(edge)
// }
fn tick(&mut self, dt: f32, graph: &Graph) {
if let Err(e) = self.traverser.advance(graph, dt * 60.0 * 1.125, &can_pacman_traverse) {
error!("Pac-Man movement error: {}", e);
}
self.texture.tick(dt);
}
}
// fn tick(&mut self, dt: f32, graph: &Graph) {
// if let Err(e) = self.traverser.advance(graph, dt * 60.0 * 1.125, &can_pacman_traverse) {
// error!("Pac-Man movement error: {}", e);
// }
// self.texture.tick(dt);
// }
// }
impl Pacman {
/// Creates a new Pac-Man instance at the specified starting node.
///
/// Sets up animated textures for all four directions with moving and stopped states.
/// The moving animation cycles through open mouth, closed mouth, and full sprites.
pub fn new(graph: &Graph, start_node: NodeId, atlas: &SpriteAtlas) -> GameResult<Self> {
let mut textures = [None, None, None, None];
let mut stopped_textures = [None, None, None, None];
// impl Pacman {
// /// Creates a new Pac-Man instance at the specified starting node.
// ///
// /// Sets up animated textures for all four directions with moving and stopped states.
// /// The moving animation cycles through open mouth, closed mouth, and full sprites.
// pub fn new(graph: &Graph, start_node: NodeId, atlas: &SpriteAtlas) -> GameResult<Self> {
// 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 = vec![
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())))?,
];
// 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 = vec![
// 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 stopped_tiles = vec![SpriteAtlas::get_tile(atlas, &format!("{moving_prefix}_b.png"))
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_b.png"))))?];
// let stopped_tiles = vec![SpriteAtlas::get_tile(atlas, &format!("{moving_prefix}_b.png"))
// .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_b.png"))))?];
textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.08)?);
stopped_textures[direction.as_usize()] = Some(AnimatedTexture::new(stopped_tiles, 0.1)?);
}
// textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.08)?);
// stopped_textures[direction.as_usize()] = Some(AnimatedTexture::new(stopped_tiles, 0.1)?);
// }
Ok(Self {
traverser: Traverser::new(graph, start_node, Direction::Left, &can_pacman_traverse),
texture: DirectionalAnimatedTexture::new(textures, stopped_textures),
})
}
}
// Ok(Self {
// traverser: Traverser::new(graph, start_node, Direction::Left, &can_pacman_traverse),
// texture: DirectionalAnimatedTexture::new(textures, stopped_textures),
// })
// }
// }
impl Collidable for Pacman {
fn position(&self) -> crate::entity::traversal::Position {
self.traverser.position
}
}
// impl Collidable for Pacman {
// fn position(&self) -> crate::entity::traversal::Position {
// self.traverser.position
// }
// }

196
src/entity/trait.rs
View File

@@ -1,114 +1,114 @@
//! Entity trait for common movement and rendering functionality.
//!
//! This module defines a trait that captures the shared behavior between
//! different game entities like Ghosts and Pac-Man, including movement,
//! rendering, and position calculations.
// //! Entity trait for common movement and rendering functionality.
// //!
// //! This module defines a trait that captures the shared behavior between
// //! different game entities like Ghosts and Pac-Man, including movement,
// //! rendering, and position calculations.
use glam::Vec2;
use sdl2::render::{Canvas, RenderTarget};
// use glam::Vec2;
// use sdl2::render::{Canvas, RenderTarget};
use crate::entity::direction::Direction;
use crate::entity::graph::{Edge, Graph, NodeId};
use crate::entity::traversal::{Position, Traverser};
use crate::error::{EntityError, GameError, GameResult, TextureError};
use crate::texture::directional::DirectionalAnimatedTexture;
use crate::texture::sprite::SpriteAtlas;
// use crate::entity::direction::Direction;
// use crate::entity::graph::{Edge, Graph, NodeId};
// use crate::entity::traversal::{Position, Traverser};
// use crate::error::{EntityError, GameError, GameResult, TextureError};
// use crate::texture::directional::DirectionalAnimatedTexture;
// use crate::texture::sprite::SpriteAtlas;
/// Trait defining common functionality for game entities that move through the graph.
///
/// This trait provides a unified interface for entities that:
/// - Move through the game graph using a traverser
/// - Render using directional animated textures
/// - Have position calculations and movement speed
#[allow(dead_code)]
pub trait Entity {
/// Returns a reference to the entity's traverser for movement control.
fn traverser(&self) -> &Traverser;
// /// Trait defining common functionality for game entities that move through the graph.
// ///
// /// This trait provides a unified interface for entities that:
// /// - Move through the game graph using a traverser
// /// - Render using directional animated textures
// /// - Have position calculations and movement speed
// #[allow(dead_code)]
// pub trait Entity {
// /// Returns a reference to the entity's traverser for movement control.
// fn traverser(&self) -> &Traverser;
/// Returns a mutable reference to the entity's traverser for movement control.
fn traverser_mut(&mut self) -> &mut Traverser;
// /// Returns a mutable reference to the entity's traverser for movement control.
// fn traverser_mut(&mut self) -> &mut Traverser;
/// Returns a reference to the entity's directional animated texture.
fn texture(&self) -> &DirectionalAnimatedTexture;
// /// Returns a reference to the entity's directional animated texture.
// fn texture(&self) -> &DirectionalAnimatedTexture;
/// Returns a mutable reference to the entity's directional animated texture.
fn texture_mut(&mut self) -> &mut DirectionalAnimatedTexture;
// /// Returns a mutable reference to the entity's directional animated texture.
// fn texture_mut(&mut self) -> &mut DirectionalAnimatedTexture;
/// Returns the movement speed multiplier for this entity.
fn speed(&self) -> f32;
// /// Returns the movement speed multiplier for this entity.
// fn speed(&self) -> f32;
/// Determines if this entity can traverse a given edge.
fn can_traverse(&self, edge: Edge) -> bool;
// /// Determines if this entity can traverse a given edge.
// fn can_traverse(&self, edge: Edge) -> bool;
/// Updates the entity's position and animation state.
///
/// This method advances movement through the graph and updates texture animation.
fn tick(&mut self, dt: f32, graph: &Graph);
// /// Updates the entity's position and animation state.
// ///
// /// This method advances movement through the graph and updates texture animation.
// fn tick(&mut self, dt: f32, graph: &Graph);
/// Calculates the current pixel position in the game world.
///
/// Converts the graph position to screen coordinates, accounting for
/// the board offset and centering the sprite.
fn get_pixel_pos(&self, graph: &Graph) -> GameResult<Vec2> {
let pos = match self.traverser().position {
Position::AtNode(node_id) => {
let node = graph.get_node(node_id).ok_or(EntityError::NodeNotFound(node_id))?;
node.position
}
Position::BetweenNodes { from, to, traversed } => {
let from_node = graph.get_node(from).ok_or(EntityError::NodeNotFound(from))?;
let to_node = graph.get_node(to).ok_or(EntityError::NodeNotFound(to))?;
let edge = graph.find_edge(from, to).ok_or(EntityError::EdgeNotFound { from, to })?;
from_node.position + (to_node.position - from_node.position) * (traversed / edge.distance)
}
};
// /// Calculates the current pixel position in the game world.
// ///
// /// Converts the graph position to screen coordinates, accounting for
// /// the board offset and centering the sprite.
// fn get_pixel_pos(&self, graph: &Graph) -> GameResult<Vec2> {
// let pos = match self.traverser().position {
// Position::AtNode(node_id) => {
// let node = graph.get_node(node_id).ok_or(EntityError::NodeNotFound(node_id))?;
// node.position
// }
// Position::BetweenNodes { from, to, traversed } => {
// let from_node = graph.get_node(from).ok_or(EntityError::NodeNotFound(from))?;
// let to_node = graph.get_node(to).ok_or(EntityError::NodeNotFound(to))?;
// let edge = graph.find_edge(from, to).ok_or(EntityError::EdgeNotFound { from, to })?;
// from_node.position + (to_node.position - from_node.position) * (traversed / edge.distance)
// }
// };
Ok(Vec2::new(
pos.x + crate::constants::BOARD_PIXEL_OFFSET.x as f32,
pos.y + crate::constants::BOARD_PIXEL_OFFSET.y as f32,
))
}
// Ok(Vec2::new(
// pos.x + crate::constants::BOARD_PIXEL_OFFSET.x as f32,
// pos.y + crate::constants::BOARD_PIXEL_OFFSET.y as f32,
// ))
// }
/// Returns the current node ID that the entity is at or moving towards.
///
/// If the entity is at a node, returns that node ID.
/// If the entity is between nodes, returns the node it's moving towards.
fn current_node_id(&self) -> NodeId {
match self.traverser().position {
Position::AtNode(node_id) => node_id,
Position::BetweenNodes { to, .. } => to,
}
}
// /// Returns the current node ID that the entity is at or moving towards.
// ///
// /// If the entity is at a node, returns that node ID.
// /// If the entity is between nodes, returns the node it's moving towards.
// fn current_node_id(&self) -> NodeId {
// match self.traverser().position {
// Position::AtNode(node_id) => node_id,
// Position::BetweenNodes { to, .. } => to,
// }
// }
/// Sets the next direction for the entity to take.
///
/// The direction is buffered and will be applied at the next opportunity,
/// typically when the entity reaches a new node.
fn set_next_direction(&mut self, direction: Direction) {
self.traverser_mut().set_next_direction(direction);
}
// /// Sets the next direction for the entity to take.
// ///
// /// The direction is buffered and will be applied at the next opportunity,
// /// typically when the entity reaches a new node.
// fn set_next_direction(&mut self, direction: Direction) {
// self.traverser_mut().set_next_direction(direction);
// }
/// Renders the entity at its current position.
///
/// Draws the appropriate directional sprite based on the entity's
/// current movement state and direction.
fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, graph: &Graph) -> GameResult<()> {
let pixel_pos = self.get_pixel_pos(graph)?;
let dest = crate::helpers::centered_with_size(
glam::IVec2::new(pixel_pos.x as i32, pixel_pos.y as i32),
glam::UVec2::new(16, 16),
);
// /// Renders the entity at its current position.
// ///
// /// Draws the appropriate directional sprite based on the entity's
// /// current movement state and direction.
// fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, graph: &Graph) -> GameResult<()> {
// let pixel_pos = self.get_pixel_pos(graph)?;
// let dest = crate::helpers::centered_with_size(
// glam::IVec2::new(pixel_pos.x as i32, pixel_pos.y as i32),
// glam::UVec2::new(16, 16),
// );
if self.traverser().position.is_stopped() {
self.texture()
.render_stopped(canvas, atlas, dest, self.traverser().direction)
.map_err(|e| GameError::Texture(TextureError::RenderFailed(e.to_string())))?;
} else {
self.texture()
.render(canvas, atlas, dest, self.traverser().direction)
.map_err(|e| GameError::Texture(TextureError::RenderFailed(e.to_string())))?;
}
// if self.traverser().position.is_stopped() {
// self.texture()
// .render_stopped(canvas, atlas, dest, self.traverser().direction)
// .map_err(|e| GameError::Texture(TextureError::RenderFailed(e.to_string())))?;
// } else {
// self.texture()
// .render(canvas, atlas, dest, self.traverser().direction)
// .map_err(|e| GameError::Texture(TextureError::RenderFailed(e.to_string())))?;
// }
Ok(())
}
}
// Ok(())
// }
// }

376
src/entity/traversal.rs
View File

@@ -1,229 +1,181 @@
use tracing::error;
// use tracing::error;
use crate::error::GameResult;
// use crate::error::GameResult;
use super::direction::Direction;
use super::graph::{Edge, Graph, NodeId};
// use super::direction::Direction;
// use super::graph::{Edge, Graph, NodeId};
/// Represents the current position of an entity traversing the graph.
///
/// This enum allows for precise tracking of whether an entity is exactly at a node
/// or moving along an edge between two nodes.
#[derive(Debug, PartialEq, Clone, Copy)]
pub enum Position {
/// The traverser is located exactly at a node.
AtNode(NodeId),
/// The traverser is on an edge between two nodes.
BetweenNodes {
from: NodeId,
to: NodeId,
/// The floating-point distance traversed along the edge from the `from` node.
traversed: f32,
},
}
// /// 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)>,
// }
#[allow(dead_code)]
impl Position {
/// Returns `true` if the position is exactly at a node.
pub fn is_at_node(&self) -> bool {
matches!(self, Position::AtNode(_))
}
// impl Traverser {
// /// Creates a new traverser starting at the given node ID.
// ///
// /// The traverser will immediately attempt to start moving in the initial direction.
// pub fn new<F>(graph: &Graph, start_node: NodeId, initial_direction: Direction, can_traverse: &F) -> Self
// where
// F: Fn(Edge) -> bool,
// {
// let mut traverser = Traverser {
// position: Position::AtNode(start_node),
// direction: initial_direction,
// next_direction: Some((initial_direction, 1)),
// };
/// Returns the `NodeId` of the current or most recently departed node.
#[allow(clippy::wrong_self_convention)]
pub fn from_node_id(&self) -> NodeId {
match self {
Position::AtNode(id) => *id,
Position::BetweenNodes { from, .. } => *from,
}
}
// // This will kickstart the traverser into motion
// if let Err(e) = traverser.advance(graph, 0.0, can_traverse) {
// error!("Traverser initialization error: {}", e);
// }
/// Returns the `NodeId` of the destination node, if currently on an edge.
#[allow(clippy::wrong_self_convention)]
pub fn to_node_id(&self) -> Option<NodeId> {
match self {
Position::AtNode(_) => None,
Position::BetweenNodes { to, .. } => Some(*to),
}
}
// traverser
// }
/// Returns `true` if the traverser is stopped at a node.
pub fn is_stopped(&self) -> bool {
matches!(self, Position::AtNode(_))
}
}
// /// 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));
// }
// }
/// 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)>,
}
// /// 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<F>(&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;
// }
// }
impl Traverser {
/// Creates a new traverser starting at the given node ID.
///
/// The traverser will immediately attempt to start moving in the initial direction.
pub fn new<F>(graph: &Graph, start_node: NodeId, initial_direction: Direction, can_traverse: &F) -> Self
where
F: Fn(Edge) -> bool,
{
let mut traverser = Traverser {
position: Position::AtNode(start_node),
direction: initial_direction,
next_direction: Some((initial_direction, 1)),
};
// 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),
// )));
// }
// This will kickstart the traverser into motion
if let Err(e) = traverser.advance(graph, 0.0, can_traverse) {
error!("Traverser initialization error: {}", e);
}
// 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(());
// }
traverser
}
// 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
// )))
// })?;
/// 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));
}
}
// let new_traversed = traversed + distance;
/// 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<F>(&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;
}
}
// 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;
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),
)));
}
// // 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.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(());
}
// self.direction = next_dir; // Remember our new direction
// self.next_direction = None; // Consume the buffered direction
// moved = true;
// }
// }
// }
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
)))
})?;
// // 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;
// }
// }
// }
// }
// }
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(())
}
}
// Ok(())
// }
// }