refactor: restructure game logic and state management into separate modules

- Moved game logic from `game.rs` to `game/mod.rs` and `game/state.rs` for better organization.
- Updated `App` to utilize the new `Game` struct and its state management.
- Refactored error handling
- Removed unused audio subsystem references

src/texture/animated.rs

@@ -1,16 +1,9 @@
-use anyhow::Result;
 use sdl2::rect::Rect;
 use sdl2::render::{Canvas, RenderTarget};
-use thiserror::Error;
 
+use crate::error::{AnimatedTextureError, GameError, GameResult, TextureError};
 use crate::texture::sprite::{AtlasTile, SpriteAtlas};
 
-#[derive(Error, Debug)]
-pub enum AnimatedTextureError {
-    #[error("Frame duration must be positive, got {0}")]
-    InvalidFrameDuration(f32),
-}
-
 #[derive(Debug, Clone)]
 pub struct AnimatedTexture {
     tiles: Vec<AtlasTile>,
@@ -20,9 +13,11 @@ pub struct AnimatedTexture {
 }
 
 impl AnimatedTexture {
-    pub fn new(tiles: Vec<AtlasTile>, frame_duration: f32) -> Result<Self, AnimatedTextureError> {
+    pub fn new(tiles: Vec<AtlasTile>, frame_duration: f32) -> GameResult<Self> {
         if frame_duration <= 0.0 {
-            return Err(AnimatedTextureError::InvalidFrameDuration(frame_duration));
+            return Err(GameError::Texture(TextureError::Animated(
+                AnimatedTextureError::InvalidFrameDuration(frame_duration),
+            )));
         }
 
         Ok(Self {
@@ -45,9 +40,10 @@ impl AnimatedTexture {
         &self.tiles[self.current_frame]
     }
 
-    pub fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, dest: Rect) -> Result<()> {
+    pub fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, dest: Rect) -> GameResult<()> {
         let mut tile = *self.current_tile();
-        tile.render(canvas, atlas, dest)
+        tile.render(canvas, atlas, dest)?;
+        Ok(())
     }
 
     /// Returns the current frame index.

src/texture/directional.rs

@@ -1,8 +1,8 @@
-use anyhow::Result;
 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;
 
@@ -32,7 +32,7 @@ impl DirectionalAnimatedTexture {
         atlas: &mut SpriteAtlas,
         dest: Rect,
         direction: Direction,
-    ) -> Result<()> {
+    ) -> GameResult<()> {
         if let Some(texture) = &self.textures[direction.as_usize()] {
             texture.render(canvas, atlas, dest)
         } else {
@@ -46,7 +46,7 @@ impl DirectionalAnimatedTexture {
         atlas: &mut SpriteAtlas,
         dest: Rect,
         direction: Direction,
-    ) -> Result<()> {
+    ) -> GameResult<()> {
         if let Some(texture) = &self.stopped_textures[direction.as_usize()] {
             texture.render(canvas, atlas, dest)
         } else {

src/texture/sprite.rs

@@ -6,6 +6,8 @@ use sdl2::render::{Canvas, RenderTarget, Texture};
 use serde::Deserialize;
 use std::collections::HashMap;
 
+use crate::error::TextureError;
+
 /// A simple sprite for stationary items like pellets and energizers.
 #[derive(Clone, Debug)]
 pub struct Sprite {
@@ -17,13 +19,19 @@ impl Sprite {
         Self { atlas_tile }
     }
 
-    pub fn render<C: RenderTarget>(&self, canvas: &mut Canvas<C>, atlas: &mut SpriteAtlas, position: glam::Vec2) -> Result<()> {
+    pub fn render<C: RenderTarget>(
+        &self,
+        canvas: &mut Canvas<C>,
+        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)
+        tile.render(canvas, atlas, dest)?;
+        Ok(())
     }
 }
 
@@ -48,9 +56,15 @@ pub struct AtlasTile {
 }
 
 impl AtlasTile {
-    pub fn render<C: RenderTarget>(&mut self, canvas: &mut Canvas<C>, atlas: &mut SpriteAtlas, dest: Rect) -> Result<()> {
+    pub fn render<C: RenderTarget>(
+        &mut self,
+        canvas: &mut Canvas<C>,
+        atlas: &mut SpriteAtlas,
+        dest: Rect,
+    ) -> Result<(), TextureError> {
         let color = self.color.unwrap_or(atlas.default_color.unwrap_or(Color::WHITE));
-        self.render_with_color(canvas, atlas, dest, color)
+        self.render_with_color(canvas, atlas, dest, color)?;
+        Ok(())
     }
 
     pub fn render_with_color<C: RenderTarget>(
@@ -59,7 +73,7 @@ impl AtlasTile {
         atlas: &mut SpriteAtlas,
         dest: Rect,
         color: Color,
-    ) -> Result<()> {
+    ) -> Result<(), TextureError> {
         let src = Rect::new(self.pos.x as i32, self.pos.y as i32, self.size.x as u32, self.size.y as u32);
 
         if atlas.last_modulation != Some(color) {
@@ -67,7 +81,7 @@ impl AtlasTile {
             atlas.last_modulation = Some(color);
         }
 
-        canvas.copy(&atlas.texture, src, dest).map_err(anyhow::Error::msg)?;
+        canvas.copy(&atlas.texture, src, dest).map_err(TextureError::RenderFailed)?;
         Ok(())
     }