feat!: implement proper error handling, drop most expect() & unwrap() usages

src/entity/trait.rs

@@ -10,6 +10,7 @@ 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;
 
@@ -48,21 +49,24 @@ pub trait Entity {
     ///
     /// Converts the graph position to screen coordinates, accounting for
     /// the board offset and centering the sprite.
-    fn get_pixel_pos(&self, graph: &Graph) -> Vec2 {
+    fn get_pixel_pos(&self, graph: &Graph) -> GameResult<Vec2> {
         let pos = match self.traverser().position {
-            Position::AtNode(node_id) => graph.get_node(node_id).unwrap().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_pos = graph.get_node(from).unwrap().position;
-                let to_pos = graph.get_node(to).unwrap().position;
-                let edge = graph.find_edge(from, to).unwrap();
-                from_pos + (to_pos - from_pos) * (traversed / edge.distance)
+                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)
             }
         };
 
-        Vec2::new(
+        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.
@@ -88,8 +92,8 @@ pub trait Entity {
     ///
     /// 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) {
-        let pixel_pos = self.get_pixel_pos(graph);
+    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),
@@ -98,11 +102,13 @@ pub trait Entity {
         if self.traverser().position.is_stopped() {
             self.texture()
                 .render_stopped(canvas, atlas, dest, self.traverser().direction)
-                .expect("Failed to render entity");
+                .map_err(|e| GameError::Texture(TextureError::RenderFailed(e.to_string())))?;
         } else {
             self.texture()
                 .render(canvas, atlas, dest, self.traverser().direction)
-                .expect("Failed to render entity");
+                .map_err(|e| GameError::Texture(TextureError::RenderFailed(e.to_string())))?;
         }
+
+        Ok(())
     }
 }