feat: add pacman death sound

.github/workflows/coverage.yaml

@@ -9,8 +9,6 @@ env:
 jobs:
   coverage:
     runs-on: ubuntu-latest
-    env:
-      COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }}
     steps:
       - name: Checkout code
         uses: actions/checkout@v5
@@ -48,35 +46,12 @@ jobs:
 
       - name: Generate coverage report
         run: |
-          just coverage
+          just coverage-codecov
 
-      - name: Download Coveralls CLI
-        if: ${{ env.COVERALLS_REPO_TOKEN != '' }}
-        run: |
-          # use GitHub Releases URL instead of coveralls.io because they can't maintain their own files; it 404s
-          curl -L https://github.com/coverallsapp/coverage-reporter/releases/download/v0.6.15/coveralls-linux-x86_64.tar.gz | tar -xz -C /usr/local/bin
-
-      - name: Upload coverage to Coveralls
-        if: ${{ env.COVERALLS_REPO_TOKEN != '' }}
-        run: |
-          if [ ! -f "lcov.info" ]; then
-            echo "Error: lcov.info file not found. Coverage generation may have failed."
-            exit 1
-          fi
-
-          for i in {1..10}; do
-            echo "Attempt $i: Uploading coverage to Coveralls..."
-            if coveralls -n report lcov.info; then
-              echo "Successfully uploaded coverage report."
-              exit 0
-            fi
-
-            if [ $i -lt 10 ]; then
-              delay=$((2**i))
-              echo "Attempt $i failed. Retrying in $delay seconds..."
-              sleep $delay
-            fi
-          done
-
-          echo "Failed to upload coverage report after 10 attempts."
-          exit 1
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: ./codecov.json
+          disable_search: true
+          verbose: true

.gitignore

@@ -14,6 +14,7 @@ assets/site/build.css
 
 # Coverage reports
 lcov.info
+codecov.json
 coverage.html
 
 # Profiling output

Justfile

@@ -2,8 +2,8 @@ set shell := ["bash", "-c"]
 set windows-shell := ["powershell.exe", "-NoLogo", "-Command"]
 
 # Regex to exclude files from coverage report, double escapes for Justfile + CLI
-# You can use src\\\\..., but the filename alone is acceptable too
-coverage_exclude_pattern := "src\\\\app\\.rs|audio\\.rs|src\\\\error\\.rs|platform\\\\emscripten\\.rs|bin\\\\.+\\.rs|main\\.rs|platform\\\\desktop\\.rs|platform\\\\tracing_buffer\\.rs|platform\\\\buffered_writer\\.rs|systems\\\\debug\\.rs|systems\\\\profiling\\.rs"
+# You can use src/..., but the filename alone is acceptable too
+coverage_exclude_pattern := "src/app\\.rs|audio\\.rs|src/error\\.rs|platform/emscripten\\.rs|bin/.+\\.rs|main\\.rs|platform/desktop\\.rs|platform/tracing_buffer\\.rs|platform/buffered_writer\\.rs|systems/debug\\.rs|systems/profiling\\.rs"
 
 binary_extension := if os() == "windows" { ".exe" } else { "" }
 
@@ -11,7 +11,7 @@ binary_extension := if os() == "windows" { ".exe" } else { "" }
 # !!! --remap-path-prefix prevents the absolute path from being used in the generated report
 
 # Generate HTML report (for humans, source line inspection)
-html: coverage
+html: coverage-lcov
     cargo llvm-cov report \
     --remap-path-prefix \
     --ignore-filename-regex "{{ coverage_exclude_pattern }}" \
@@ -19,13 +19,13 @@ html: coverage
     --open
 
 # Display report (for humans)
-report-coverage: coverage
+report-coverage: coverage-lcov
     cargo llvm-cov report \
     --remap-path-prefix \
     --ignore-filename-regex "{{ coverage_exclude_pattern }}"
 
-# Run & generate report (for CI)
-coverage:
+# Run & generate LCOV report (as base report)
+coverage-lcov:
     cargo llvm-cov \
     --lcov \
     --remap-path-prefix \
@@ -34,6 +34,16 @@ coverage:
     --profile coverage \
     --no-fail-fast nextest
 
+# Run & generate Codecov report (for CI)
+coverage-codecov:
+    cargo llvm-cov \
+    --codecov \
+    --remap-path-prefix \
+    --ignore-filename-regex "{{ coverage_exclude_pattern }}" \
+    --output-path codecov.json \
+    --profile coverage \
+    --no-fail-fast nextest
+
 # Profile the project using 'samply'
 samply:
     cargo build --profile profile

README.md

@@ -1,16 +1,16 @@
 # Pac-Man
 
-[![Tests Status][badge-test]][test] [![Build Status][badge-build]][build] [![If you're seeing this, Coveralls.io is broken again and it's not my fault.][badge-coverage]][coverage] [![Online Demo][badge-online-demo]][demo] [![Last Commit][badge-last-commit]][commits]
+[![Tests Status][badge-test]][test] [![Build Status][badge-build]][build] [![Code Coverage][badge-coverage]][coverage] [![Online Demo][badge-online-demo]][demo] [![Last Commit][badge-last-commit]][commits]
 
 [badge-test]: https://github.com/Xevion/Pac-Man/actions/workflows/tests.yaml/badge.svg
 [badge-build]: https://github.com/Xevion/Pac-Man/actions/workflows/build.yaml/badge.svg
-[badge-coverage]: https://coveralls.io/repos/github/Xevion/Pac-Man/badge.svg?branch=master
+[badge-coverage]: https://codecov.io/github/Xevion/Pac-Man/branch/master/graph/badge.svg?token=R2RBYUQK3I
 [badge-demo]: https://img.shields.io/github/deployments/Xevion/Pac-Man/github-pages?label=GitHub%20Pages
 [badge-online-demo]: https://img.shields.io/badge/GitHub%20Pages-Demo-brightgreen
 [badge-last-commit]: https://img.shields.io/github/last-commit/Xevion/Pac-Man
 [build]: https://github.com/Xevion/Pac-Man/actions/workflows/build.yaml
 [test]: https://github.com/Xevion/Pac-Man/actions/workflows/tests.yaml
-[coverage]: https://coveralls.io/github/Xevion/Pac-Man?branch=master
+[coverage]: https://codecov.io/github/Xevion/Pac-Man
 [demo]: https://xevion.github.io/Pac-Man/
 [commits]: https://github.com/Xevion/Pac-Man/commits/master
 

codecov.yml

@@ -0,0 +1,3 @@
+ignore:
+  - "src/(?:bin|platform))/.+\\.rs"
+  - "src/(?:app|events|formatter)\\.rs"

src/asset.rs

@@ -19,6 +19,8 @@ pub enum Asset {
     AtlasImage,
     /// Terminal Vector font for text rendering (TerminalVector.ttf)
     Font,
+    /// Sound effect for Pac-Man's death
+    DeathSound,
 }
 
 impl Asset {
@@ -37,6 +39,7 @@ impl Asset {
             Wav4 => "sound/waka/4.ogg",
             AtlasImage => "atlas.png",
             Font => "TerminalVector.ttf",
+            DeathSound => "sound/pacman_death.wav",
         }
     }
 }

src/audio.rs

@@ -16,6 +16,7 @@ const SOUND_ASSETS: [Asset; 4] = [Asset::Wav1, Asset::Wav2, Asset::Wav3, Asset::
 pub struct Audio {
     _mixer_context: Option<mixer::Sdl2MixerContext>,
     sounds: Vec<Chunk>,
+    death_sound: Option<Chunk>,
     next_sound_index: usize,
     muted: bool,
     disabled: bool,
@@ -44,6 +45,7 @@ impl Audio {
             return Self {
                 _mixer_context: None,
                 sounds: Vec::new(),
+                death_sound: None,
                 next_sound_index: 0,
                 muted: false,
                 disabled: true,
@@ -65,6 +67,7 @@ impl Audio {
                 return Self {
                     _mixer_context: None,
                     sounds: Vec::new(),
+                    death_sound: None,
                     next_sound_index: 0,
                     muted: false,
                     disabled: true,
@@ -93,12 +96,33 @@ impl Audio {
             }
         }
 
+        let death_sound = match get_asset_bytes(Asset::DeathSound) {
+            Ok(data) => match RWops::from_bytes(&data) {
+                Ok(rwops) => match rwops.load_wav() {
+                    Ok(chunk) => Some(chunk),
+                    Err(e) => {
+                        tracing::warn!("Failed to load death sound from asset API: {}", e);
+                        None
+                    }
+                },
+                Err(e) => {
+                    tracing::warn!("Failed to create RWops for death sound: {}", e);
+                    None
+                }
+            },
+            Err(e) => {
+                tracing::warn!("Failed to load death sound asset: {}", e);
+                None
+            }
+        };
+
         // If no sounds loaded successfully, disable audio
-        if sounds.is_empty() {
+        if sounds.is_empty() && death_sound.is_none() {
             tracing::warn!("No sounds loaded successfully. Audio will be disabled.");
             return Self {
                 _mixer_context: Some(mixer_context),
                 sounds: Vec::new(),
+                death_sound: None,
                 next_sound_index: 0,
                 muted: false,
                 disabled: true,
@@ -108,6 +132,7 @@ impl Audio {
         Audio {
             _mixer_context: Some(mixer_context),
             sounds,
+            death_sound,
             next_sound_index: 0,
             muted: false,
             disabled: false,
@@ -138,6 +163,24 @@ impl Audio {
         self.next_sound_index = (self.next_sound_index + 1) % self.sounds.len();
     }
 
+    /// Plays the death sound effect.
+    pub fn death(&mut self) {
+        if self.disabled || self.muted {
+            return;
+        }
+
+        if let Some(chunk) = &self.death_sound {
+            mixer::Channel::all().play(chunk, 0).ok();
+        }
+    }
+
+    /// Halts all currently playing audio channels.
+    pub fn stop_all(&mut self) {
+        if !self.disabled {
+            mixer::Channel::all().halt();
+        }
+    }
+
     /// Instantly mutes or unmutes all audio channels by adjusting their volume.
     ///
     /// Sets all 4 mixer channels to zero volume when muting, or restores them to

src/platform/desktop.rs

@@ -65,6 +65,7 @@ pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
         Asset::Wav4 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/4.ogg"))),
         Asset::AtlasImage => Ok(Cow::Borrowed(include_bytes!("../../assets/game/atlas.png"))),
         Asset::Font => Ok(Cow::Borrowed(include_bytes!("../../assets/game/TerminalVector.ttf"))),
+        Asset::DeathSound => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/pacman_death.wav"))),
     }
 }
 

src/systems/audio.rs

@@ -26,6 +26,10 @@ pub struct AudioState {
 pub enum AudioEvent {
     /// Play the "eat" sound when Pac-Man consumes a pellet
     PlayEat,
+    /// Play the death sound
+    PlayDeath,
+    /// Stop all currently playing sounds
+    StopAll,
 }
 
 /// Non-send resource wrapper for SDL2 audio system
@@ -59,6 +63,16 @@ pub fn audio_system(
                     // 4 eat sounds available
                 }
             }
+            AudioEvent::PlayDeath => {
+                if !audio.0.is_disabled() && !audio_state.muted {
+                    audio.0.death();
+                }
+            }
+            AudioEvent::StopAll => {
+                if !audio.0.is_disabled() {
+                    audio.0.stop_all();
+                }
+            }
         }
     }
 }

src/texture/sprites.rs

@@ -15,6 +15,8 @@ pub enum PacmanSprite {
     Moving(Direction, u8),
     /// The full, closed-mouth Pac-Man sprite.
     Full,
+    /// A single frame of the dying animation.
+    Dying(u8),
 }
 
 /// Represents the color of a frightened ghost.
@@ -60,45 +62,50 @@ impl GameSprite {
     /// This path corresponds to the filename in the texture atlas JSON file.
     pub fn to_path(self) -> String {
         match self {
-            GameSprite::Pacman(sprite) => match sprite {
-                PacmanSprite::Moving(dir, frame) => {
-                    let frame_char = match frame {
-                        0 => 'a',
-                        1 => 'b',
-                        _ => panic!("Invalid animation frame"),
-                    };
-                    format!("pacman/{}_{}.png", dir.as_ref().to_lowercase(), frame_char)
+            GameSprite::Pacman(PacmanSprite::Moving(dir, frame)) => format!(
+                "pacman/{}_{}.png",
+                dir.as_ref(),
+                match frame {
+                    0 => "a",
+                    1 => "b",
+                    _ => panic!("Invalid animation frame"),
                 }
-                PacmanSprite::Full => "pacman/full.png".to_string(),
-            },
-            GameSprite::Ghost(sprite) => match sprite {
-                GhostSprite::Normal(ghost, dir, frame) => {
-                    let frame_char = match frame {
-                        0 => 'a',
-                        1 => 'b',
-                        _ => panic!("Invalid animation frame"),
-                    };
-                    format!("ghost/{}/{}_{}.png", ghost.as_str(), dir.as_ref().to_lowercase(), frame_char)
-                }
-                GhostSprite::Frightened(color, frame) => {
-                    let frame_char = match frame {
-                        0 => 'a',
-                        1 => 'b',
-                        _ => panic!("Invalid animation frame"),
-                    };
-                    let color_str = match color {
-                        FrightenedColor::Blue => "blue",
-                        FrightenedColor::White => "white",
-                    };
-                    format!("ghost/frightened/{}_{}.png", color_str, frame_char)
-                }
-                GhostSprite::Eyes(dir) => format!("ghost/eyes/{}.png", dir.as_ref().to_lowercase()),
-            },
-            GameSprite::Maze(sprite) => match sprite {
-                MazeSprite::Tile(index) => format!("maze/tiles/{}.png", index),
-                MazeSprite::Pellet => "maze/pellet.png".to_string(),
-                MazeSprite::Energizer => "maze/energizer.png".to_string(),
-            },
+            ),
+            GameSprite::Pacman(PacmanSprite::Full) => "pacman/full.png".to_string(),
+            GameSprite::Pacman(PacmanSprite::Dying(frame)) => format!("pacman/death/{}.png", frame),
+
+            // Ghost sprites
+            GameSprite::Ghost(GhostSprite::Normal(ghost_type, dir, frame)) => {
+                let frame_char = match frame {
+                    0 => 'a',
+                    1 => 'b',
+                    _ => panic!("Invalid animation frame"),
+                };
+                format!(
+                    "ghost/{}/{}_{}.png",
+                    ghost_type.as_str(),
+                    dir.as_ref().to_lowercase(),
+                    frame_char
+                )
+            }
+            GameSprite::Ghost(GhostSprite::Frightened(color, frame)) => {
+                let frame_char = match frame {
+                    0 => 'a',
+                    1 => 'b',
+                    _ => panic!("Invalid animation frame"),
+                };
+                let color_str = match color {
+                    FrightenedColor::Blue => "blue",
+                    FrightenedColor::White => "white",
+                };
+                format!("ghost/frightened/{}_{}.png", color_str, frame_char)
+            }
+            GameSprite::Ghost(GhostSprite::Eyes(dir)) => format!("ghost/eyes/{}.png", dir.as_ref().to_lowercase()),
+
+            // Maze sprites
+            GameSprite::Maze(MazeSprite::Tile(index)) => format!("maze/tiles/{}.png", index),
+            GameSprite::Maze(MazeSprite::Pellet) => "maze/pellet.png".to_string(),
+            GameSprite::Maze(MazeSprite::Energizer) => "maze/energizer.png".to_string(),
         }
     }
 }

tests/asset.rs

@@ -15,11 +15,3 @@ fn all_asset_paths_exist() {
         assert_that(&metadata.len()).is_greater_than(1024);
     }
 }
-
-#[test]
-fn asset_paths_are_non_empty() {
-    for asset in Asset::iter() {
-        let path = asset.path();
-        assert_that(&path.is_empty()).is_false();
-    }
-}

tests/constants.rs

@@ -1,24 +0,0 @@
-use pacman::constants::*;
-use speculoos::prelude::*;
-
-#[test]
-fn test_raw_board_structure() {
-    // Test board dimensions match expected size
-    assert_that(&RAW_BOARD.len()).is_equal_to(BOARD_CELL_SIZE.y as usize);
-    for row in RAW_BOARD.iter() {
-        assert_that(&row.len()).is_equal_to(BOARD_CELL_SIZE.x as usize);
-    }
-
-    // Test boundaries are properly walled
-    assert_that(&RAW_BOARD[0].chars().all(|c| c == '#')).is_true();
-    assert_that(&RAW_BOARD[RAW_BOARD.len() - 1].chars().all(|c| c == '#')).is_true();
-}
-
-#[test]
-fn test_raw_board_contains_required_elements() {
-    // Test that essential game elements are present
-    assert_that(&RAW_BOARD.iter().any(|row| row.contains('X'))).is_true();
-    assert_that(&RAW_BOARD.iter().any(|row| row.contains("=="))).is_true();
-    assert_that(&RAW_BOARD.iter().any(|row| row.chars().any(|c| c == 'T'))).is_true();
-    assert_that(&RAW_BOARD.iter().any(|row| row.chars().any(|c| c == 'o'))).is_true();
-}

tests/error.rs

@@ -1,76 +1,7 @@
-use pacman::error::{
-    AssetError, EntityError, GameError, GameResult, IntoGameError, MapError, OptionExt, ParseError, ResultExt, TextureError,
-};
+use pacman::error::{GameError, GameResult, IntoGameError, OptionExt, ResultExt};
 use speculoos::prelude::*;
 use std::io;
 
-#[test]
-fn test_game_error_from_asset_error() {
-    let asset_error = AssetError::NotFound("test.png".to_string());
-    let game_error: GameError = asset_error.into();
-    assert_that(&matches!(game_error, GameError::Asset(_))).is_true();
-}
-
-#[test]
-fn test_game_error_from_parse_error() {
-    let parse_error = ParseError::UnknownCharacter('Z');
-    let game_error: GameError = parse_error.into();
-    assert_that(&matches!(game_error, GameError::MapParse(_))).is_true();
-}
-
-#[test]
-fn test_game_error_from_map_error() {
-    let map_error = MapError::NodeNotFound(42);
-    let game_error: GameError = map_error.into();
-    assert_that(&matches!(game_error, GameError::Map(_))).is_true();
-}
-
-#[test]
-fn test_game_error_from_texture_error() {
-    let texture_error = TextureError::LoadFailed("Failed to load".to_string());
-    let game_error: GameError = texture_error.into();
-    assert_that(&matches!(game_error, GameError::Texture(_))).is_true();
-}
-
-#[test]
-fn test_game_error_from_entity_error() {
-    let entity_error = EntityError::NodeNotFound(10);
-    let game_error: GameError = entity_error.into();
-    assert_that(&matches!(game_error, GameError::Entity(_))).is_true();
-}
-
-#[test]
-fn test_game_error_from_io_error() {
-    let io_error = io::Error::new(io::ErrorKind::NotFound, "File not found");
-    let game_error: GameError = io_error.into();
-    assert_that(&matches!(game_error, GameError::Io(_))).is_true();
-}
-
-#[test]
-fn test_asset_error_from_io_error() {
-    let io_error = io::Error::new(io::ErrorKind::PermissionDenied, "Permission denied");
-    let asset_error: AssetError = io_error.into();
-    assert_that(&matches!(asset_error, AssetError::Io(_))).is_true();
-}
-
-#[test]
-fn test_parse_error_display() {
-    let error = ParseError::UnknownCharacter('!');
-    assert_that(&error.to_string()).is_equal_to("Unknown character in board: !".to_string());
-
-    let error = ParseError::InvalidHouseDoorCount(3);
-    assert_that(&error.to_string()).is_equal_to("House door must have exactly 2 positions, found 3".to_string());
-}
-
-#[test]
-fn test_entity_error_display() {
-    let error = EntityError::NodeNotFound(42);
-    assert_that(&error.to_string()).is_equal_to("Node not found in graph: 42".to_string());
-
-    let error = EntityError::EdgeNotFound { from: 1, to: 2 };
-    assert_that(&error.to_string()).is_equal_to("Edge not found: from 1 to 2".to_string());
-}
-
 #[test]
 fn test_into_game_error_trait() {
     let result: Result<i32, io::Error> = Err(io::Error::new(io::ErrorKind::Other, "test error"));

tests/profiling.rs

@@ -73,25 +73,6 @@ fn test_default_zero_timing_for_unused_systems() {
     }
 }
 
-#[test]
-fn test_pre_populated_timing_entries() {
-    let timings = SystemTimings::default();
-
-    // Verify that we can add timing to any SystemId without panicking
-    // (this would fail with the old implementation if the entry didn't exist)
-    // Use the same tick for all systems to avoid zero-padding
-    for id in SystemId::iter() {
-        timings.add_timing(id, Duration::from_nanos(1), 1);
-    }
-
-    // Verify all systems now have non-zero timing
-    let stats = timings.get_stats(1);
-    for id in SystemId::iter() {
-        let (avg, _) = stats.get(&id).unwrap();
-        assert_that(&(*avg > Duration::ZERO)).is_true();
-    }
-}
-
 #[test]
 fn test_total_system_timing() {
     let timings = SystemTimings::default();

tests/sprites.rs

@@ -0,0 +1,73 @@
+//! Tests for the sprite path generation.
+use pacman::{
+    game::ATLAS_FRAMES,
+    map::direction::Direction,
+    systems::components::Ghost,
+    texture::sprites::{FrightenedColor, GameSprite, GhostSprite, MazeSprite, PacmanSprite},
+};
+
+#[test]
+fn test_all_sprite_paths_exist() {
+    let mut sprites_to_test = Vec::new();
+
+    // Pac-Man sprites
+    for &dir in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] {
+        for frame in 0..2 {
+            sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Moving(dir, frame)));
+        }
+    }
+    sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Full));
+    for frame in 0..=10 {
+        sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Dying(frame)));
+    }
+
+    // Ghost sprites
+    for &ghost in &[Ghost::Blinky, Ghost::Pinky, Ghost::Inky, Ghost::Clyde] {
+        for &dir in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] {
+            for frame in 0..2 {
+                sprites_to_test.push(GameSprite::Ghost(GhostSprite::Normal(ghost, dir, frame)));
+            }
+            sprites_to_test.push(GameSprite::Ghost(GhostSprite::Eyes(dir)));
+        }
+    }
+    for &color in &[FrightenedColor::Blue, FrightenedColor::White] {
+        for frame in 0..2 {
+            sprites_to_test.push(GameSprite::Ghost(GhostSprite::Frightened(color, frame)));
+        }
+    }
+
+    // Maze sprites
+    for i in 0..=34 {
+        sprites_to_test.push(GameSprite::Maze(MazeSprite::Tile(i)));
+    }
+    sprites_to_test.push(GameSprite::Maze(MazeSprite::Pellet));
+    sprites_to_test.push(GameSprite::Maze(MazeSprite::Energizer));
+
+    for sprite in sprites_to_test {
+        let path = sprite.to_path();
+        assert!(
+            ATLAS_FRAMES.contains_key(&path),
+            "Sprite path '{}' does not exist in the atlas.",
+            path
+        );
+    }
+}
+
+#[test]
+fn test_invalid_sprite_paths_do_not_exist() {
+    let invalid_sprites = vec![
+        // An invalid Pac-Man dying frame
+        GameSprite::Pacman(PacmanSprite::Dying(99)),
+        // An invalid maze tile
+        GameSprite::Maze(MazeSprite::Tile(99)),
+    ];
+
+    for sprite in invalid_sprites {
+        let path = sprite.to_path();
+        assert!(
+            !ATLAS_FRAMES.contains_key(&path),
+            "Invalid sprite path '{}' was found in the atlas, but it should not exist.",
+            path
+        );
+    }
+}

tests/ttf.rs

@@ -0,0 +1,115 @@
+use pacman::texture::ttf::{TtfAtlas, TtfRenderer};
+use sdl2::pixels::Color;
+
+mod common;
+
+#[test]
+fn text_width_calculates_correctly_for_empty_string() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer = TtfRenderer::new(1.0);
+    let width = renderer.text_width(&atlas, "");
+
+    assert_eq!(width, 0);
+}
+
+#[test]
+fn text_width_calculates_correctly_for_single_character() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer = TtfRenderer::new(1.0);
+    let width = renderer.text_width(&atlas, "A");
+
+    assert!(width > 0);
+}
+
+#[test]
+fn text_width_scales_correctly() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer1 = TtfRenderer::new(1.0);
+    let renderer2 = TtfRenderer::new(2.0);
+
+    let width1 = renderer1.text_width(&atlas, "Test");
+    let width2 = renderer2.text_width(&atlas, "Test");
+
+    assert_eq!(width2, width1 * 2);
+}
+
+#[test]
+fn text_height_returns_non_zero_for_valid_atlas() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer = TtfRenderer::new(1.0);
+    let height = renderer.text_height(&atlas);
+
+    assert!(height > 0);
+}
+
+#[test]
+fn text_height_scales_correctly() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer1 = TtfRenderer::new(1.0);
+    let renderer2 = TtfRenderer::new(2.0);
+
+    let height1 = renderer1.text_height(&atlas);
+    let height2 = renderer2.text_height(&atlas);
+
+    assert_eq!(height2, height1 * 2);
+}
+
+#[test]
+fn render_text_handles_empty_string() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer = TtfRenderer::new(1.0);
+    let result = renderer.render_text(&mut canvas, &mut atlas, "", glam::Vec2::new(0.0, 0.0), Color::WHITE);
+
+    assert!(result.is_ok());
+}
+
+#[test]
+fn render_text_handles_single_character() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer = TtfRenderer::new(1.0);
+    let result = renderer.render_text(&mut canvas, &mut atlas, "A", glam::Vec2::new(10.0, 10.0), Color::RED);
+
+    assert!(result.is_ok());
+}