@@ -62,3 +62,118 @@ def test_get_animations(proc):
     gid, frames = animations[0]
     assert gid == proc._GID_WATER
     assert all(isinstance(f[0], int) and isinstance(f[1], int) for f in frames)
+
+
+def test_reload_animations_populates_structures(proc):
+    proc.reload_animations()
+    assert proc._tracked_gids == {proc._GID_WATER}
+    assert len(proc._animation_map) == 1
+    assert len(proc._animation_queue) == 1
+
+
+def test_process_animation_queue_changes_frames(proc):
+    proc.reload_animations()
+
+    # Touch a WATER tile so it becomes tracked for animation
+    # (1,0) is WATER because 1+0 = 1 (odd)
+    proc.get_tile_image(1, 0, 0)
+
+    # Get the real animation token
+    token = next(iter(proc._animation_queue))
+
+    # Force the animation to trigger immediately
+    token.next = 0
+
+    tile_view = pygame.Rect(0, 0, 40, 30)
+    updates = proc.process_animation_queue(tile_view)
+
+    # Should produce at least one updated tile
+    assert updates
+
+    x, y, layer, surf = updates[0]
+
+    # The returned surface must be one of the animation frames
+    expected_frames = {frame.image for frame in token.frames}
+
+    assert surf in expected_frames
+
+
+def test_get_tile_image_animated(proc):
+    proc.reload_animations()
+    # Force animation tracking
+    proc._get_tile_gid = lambda x, y, l: proc._GID_WATER
+
+    img = proc.get_tile_image(0, 0, 0)
+    assert isinstance(img, Surface)
+
+
+def test_surfaces_are_unique(proc):
+    assert proc._surfaces[proc._GID_GRASS] is not proc._surfaces[proc._GID_WATER]
+
+
+def test_convert_surfaces_noop(proc):
+    surf = Surface((32, 32))
+    proc.convert_surfaces(surf, alpha=True)  # should not crash
+
+
+def test_process_animation_queue_second_cycle(proc):
+    proc.reload_animations()
+
+    # Touch a WATER tile so it becomes tracked for animation
+    proc.get_tile_image(1, 0, 0)  # (1,0) is WATER
+
+    # Get the real animation token
+    token = next(iter(proc._animation_queue))
+
+    # Force animation to trigger immediately
+    token.next = 0
+
+    tile_view = pygame.Rect(0, 0, 40, 30)
+
+    # First update
+    updates1 = proc.process_animation_queue(tile_view)
+    assert updates1
+    _, _, _, surf1 = updates1[0]
+
+    # Force next frame to be ready
+    token.next = 0
+
+    # Second update
+    updates2 = proc.process_animation_queue(tile_view)
+    assert updates2
+    _, _, _, surf2 = updates2[0]
+
+    # Both frames must be valid animation frames
+    expected_frames = {frame.image for frame in token.frames}
+    assert surf1 in expected_frames
+    assert surf2 in expected_frames
+
+
+def test_process_animation_queue_stress(proc):
+    proc.reload_animations()
+
+    # Touch a WATER tile so it becomes tracked for animation
+    # (1,0) is WATER because 1+0 = 1 (odd)
+    proc.get_tile_image(1, 0, 0)
+
+    token = next(iter(proc._animation_queue))
+    tile_view = pygame.Rect(0, 0, 40, 30)
+
+    # Collect all possible animation frame surfaces
+    expected_frames = {frame.image for frame in token.frames}
+
+    # Run many cycles to ensure stability
+    for _ in range(50):
+        # Force animation to be ready
+        token.next = 0
+
+        updates = proc.process_animation_queue(tile_view)
+        assert updates, "Animation stopped producing updates during stress test"
+
+        x, y, layer, surf = updates[0]
+
+        # Returned frame must always be valid
+        assert surf in expected_frames
+
+        # Position must remain tracked
+        assert (1, 0, 0) in token.positions
@@ -1,4 +1,5 @@
 from collections.abc import Iterable
+from unittest.mock import MagicMock
 
 import pytest
 from pygame.rect import Rect
@@ -129,3 +130,75 @@ def test_is_on_map(adapter, x, y, expected):
 )
 def test_pixel_to_tile(adapter, px, py, expected):
     assert adapter.pixel_to_tile(px, py) == expected
+
+
+def test_get_tile_image_animated_tile(adapter):
+    surf = Surface((32, 32))
+    adapter._animated_tile[(1, 2, 0)] = surf
+    assert adapter.get_tile_image(1, 2, 0) is surf
+
+
+def test_get_tile_image_animation_map_initial_frame(adapter):
+    surf = Surface((32, 32))
+    token = MagicMock()
+    token.frames = [MagicMock(image=surf)]
+    token.positions = set()
+    adapter._animation_map = {123: token}
+    adapter._get_tile_gid = lambda x, y, l: 123
+
+    img = adapter.get_tile_image(0, 0, 0)
+    assert img is surf
+    assert (0, 0, 0) in token.positions
+
+
+def test_process_animation_queue_updates_tiles(adapter):
+    surf1 = Surface((32, 32))
+    surf2 = Surface((32, 32))
+
+    token = MagicMock()
+    token.next = 0
+    token.positions = {(1, 1, 0)}
+
+    # After first advance, next should be > last_time to break the loop
+    def advance_mock(t):
+        token.next = t + 999  # ensure loop stops
+        return MagicMock(image=surf2)
+
+    token.advance.side_effect = advance_mock
+
+    adapter._animation_queue = [token]
+    adapter._last_time = 1
+    adapter._get_tile_image = lambda x, y, l: surf1
+
+    tile_view = Rect(0, 0, 10, 10)
+    updates = adapter.process_animation_queue(tile_view)
+
+    assert updates == [(1, 1, 0, surf2)]
+
+
+def test_get_tile_images_by_rect_iteration_order(adapter):
+    calls = []
+    adapter._get_tile_image = lambda x, y, l: calls.append((x, y)) or None
+
+    rect = Rect(0, 0, 1, 1)
+    list(adapter.get_tile_images_by_rect(rect))
+
+    assert calls == [(0, 0)]
+
+
+def test_update_time_does_not_advance_when_paused(adapter):
+    adapter.pause_animations()
+    before = adapter._last_time
+    adapter._update_time()
+    assert adapter._last_time == before
+
+
+def test_set_animation_speed_multiplier_applies(adapter):
+    token1 = MagicMock()
+    token2 = MagicMock()
+    adapter._animation_queue = [token1, token2]
+
+    adapter.set_animation_speed_multiplier(2.0)
+
+    assert token1.speed_multiplier == 2.0
+    assert token2.speed_multiplier == 2.0
@@ -16,13 +16,18 @@ def mock_tmx():
     mock.height = 10
     mock.visible_tile_layers = [0]
 
-    mock.images = [Surface((16, 16)), Surface((16, 16))]
+    img0 = Surface((16, 16))
+    img1 = Surface((16, 16))
+    img0.fill((255, 0, 0))
+    img1.fill((0, 255, 0))
+    mock.images = [img0, img1]
 
     mock.layers = [MagicMock()]
+    mock.layers[0].visible = True
     mock.layers[0].data = [[1 for _ in range(10)] for _ in range(10)]
 
-    mock.tile_properties = {1: {"frames": [(0, 100)]}}
-    mock.get_tile_image.return_value = Surface((16, 16))
+    mock.tile_properties = {1: {"frames": [(0, 100), (1, 100)]}}
+    mock.get_tile_image = lambda x, y, l: None
     mock.filename = "test.tmx"
     return mock
 
@@ -83,3 +88,66 @@ def test_convert_surfaces_alpha_and_non_alpha(mock_tmx):
     assert isinstance(data.tmx.images[0], Surface) or data.tmx.images[0] is None
     data.convert_surfaces(parent, alpha=True)
     assert isinstance(data.tmx.images[0], Surface) or data.tmx.images[0] is None
+
+
+def test_reload_animations_populates_structures(tiled_map_data):
+    tiled_map_data.reload_animations()
+    assert tiled_map_data._tracked_gids == {1}
+    assert len(tiled_map_data._animation_map) == 1
+    assert len(tiled_map_data._animation_queue) >= 1
+
+
+def test_process_animation_queue_updates_tiles(tiled_map_data):
+    tiled_map_data.reload_animations()
+
+    # Touch tile (0,0,0) so it becomes tracked
+    tiled_map_data.get_tile_image(0, 0, 0)
+    target_pos = (0, 0, 0)
+
+    # Ensure it is tracked by at least one token
+    token = None
+    for t in tiled_map_data._animation_queue:
+        if target_pos in t.positions:
+            token = t
+            break
+
+    assert token is not None
+
+    # Force this token to be "ready" and ensure call does not crash
+    token.next = 0
+    tile_view = pygame.Rect(0, 0, 10, 10)
+    updates = tiled_map_data.process_animation_queue(tile_view)
+
+    assert isinstance(updates, list)
+
+
+def test_get_tile_images_by_rect_coordinates(tiled_map_data):
+    rect = (0, 0, 2, 2)
+    tiles = list(tiled_map_data.get_tile_images_by_rect(rect))
+
+    xs = {x for x, y, layer, surf in tiles}
+    ys = {y for x, y, layer, surf in tiles}
+
+    assert xs == {0, 1}
+    assert ys == {0, 1}
+
+
+def test_convert_surfaces_modifies_images(mock_tmx):
+    data = TiledMapData(mock_tmx)
+    parent = Surface((16, 16))
+
+    before = data.tmx.images[0]
+    data.convert_surfaces(parent, alpha=False)
+    after = data.tmx.images[0]
+
+    assert isinstance(after, Surface)
+    assert after is not before
+
+
+def test_get_tile_gid_invalid_layer(tiled_map_data):
+    assert tiled_map_data._get_tile_gid(0, 0, 99) is None
+
+
+def test_get_tile_image_invalid_coords(tiled_map_data):
+    img = tiled_map_data.get_tile_image(999, 999, 0)
+    assert img is None