tileforge 0.1.1__tar.gz

tileforge-0.1.1/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026-present Joshua Hegedus <josh.hegedus@outlook.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

tileforge-0.1.1/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: tileforge
+Version: 0.1.1
+Summary: A pygame rendering engine for top-down tile sets.
+Author-email: Joshua Hegedus <josh.hegedus@outlook.com>
+License: MIT License
+        
+        Copyright (c) 2026-present Joshua Hegedus <josh.hegedus@outlook.com>
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+        associated documentation files (the "Software"), to deal in the Software without restriction, including
+        without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+        following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial
+        portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+        LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+        EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+        IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+        USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/lsc-jh/tileforge
+Project-URL: Repository, https://github.com/lsc-jh/tileforge
+Keywords: rendering,engine,tile set,top-down
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame-ce
+Dynamic: license-file
+
+# Tile Forge
+
+This is a package for rendering top-down maps from a provided tile set image.
+
+## Class Diagram
+
+```mermaid
+---
+title: Class Relations
+---
+
+classDiagram
+    Renderer *-- Tileset
+    Renderer *-- Map
+    class Tileset {
+        + all_properties: dict[int, set[int]]
+        + tile_size: int
+        + path: str
+        + load()
+        + get_scaled_tiles(scale: int)
+        + has_property(tile_index: int, property_id: int): bool
+        + set_property(tile_index: int, property_index: int): void
+        + remove_property(tile_index: int, property_index: int): void
+        + toggle_property(tile_index: int, property_index: int): void
+    }
+
+    class Map {
+        + width: int
+        + height: int
+        + layers: list[Layer]
+        + set_layers(layers: list[Layer])
+        + set_layer_count(count: int)
+        + add_layer(layer: Layer)
+        + cell_has_property(tileset: Tileset, pos: tuple[int, int], property_id: int): bool
+    }
+
+    class Renderer {
+        - __map: Map
+        - __tileset: Tileset
+        + render_tile_size: int
+        + tiles: list[Surface]
+        + set_render_scale(scale: int)
+        + render(surface: Surface, offset: [int, int], callback): void
+    }
+```
+
+## Usage
+
+```python
+import pygame
+from tileforge import Tileset, Map, Renderer
+
+pygame.init()
+
+# You need a pygame surface to render the map, so make sure to initialize pygame first
+surface = pygame.Surface((640, 480))  # Create a surface to render on
+
+# Load the tileset and map
+tileset = Tileset("path/to/tileset.png", 32)
+tileset.load()
+
+# Create a map with the loaded tileset
+map = Map(10, 10)  # 10x10
+
+# Create a renderer and render the map
+renderer = Renderer(tileset, map)
+renderer.render(surface)
+```

tileforge-0.1.1/README.md

@@ -0,0 +1,68 @@
+# Tile Forge
+
+This is a package for rendering top-down maps from a provided tile set image.
+
+## Class Diagram
+
+```mermaid
+---
+title: Class Relations
+---
+
+classDiagram
+    Renderer *-- Tileset
+    Renderer *-- Map
+    class Tileset {
+        + all_properties: dict[int, set[int]]
+        + tile_size: int
+        + path: str
+        + load()
+        + get_scaled_tiles(scale: int)
+        + has_property(tile_index: int, property_id: int): bool
+        + set_property(tile_index: int, property_index: int): void
+        + remove_property(tile_index: int, property_index: int): void
+        + toggle_property(tile_index: int, property_index: int): void
+    }
+
+    class Map {
+        + width: int
+        + height: int
+        + layers: list[Layer]
+        + set_layers(layers: list[Layer])
+        + set_layer_count(count: int)
+        + add_layer(layer: Layer)
+        + cell_has_property(tileset: Tileset, pos: tuple[int, int], property_id: int): bool
+    }
+
+    class Renderer {
+        - __map: Map
+        - __tileset: Tileset
+        + render_tile_size: int
+        + tiles: list[Surface]
+        + set_render_scale(scale: int)
+        + render(surface: Surface, offset: [int, int], callback): void
+    }
+```
+
+## Usage
+
+```python
+import pygame
+from tileforge import Tileset, Map, Renderer
+
+pygame.init()
+
+# You need a pygame surface to render the map, so make sure to initialize pygame first
+surface = pygame.Surface((640, 480))  # Create a surface to render on
+
+# Load the tileset and map
+tileset = Tileset("path/to/tileset.png", 32)
+tileset.load()
+
+# Create a map with the loaded tileset
+map = Map(10, 10)  # 10x10
+
+# Create a renderer and render the map
+renderer = Renderer(tileset, map)
+renderer.render(surface)
+```

tileforge-0.1.1/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "tileforge"
+version = "0.1.1"
+description = "A pygame rendering engine for top-down tile sets."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { file = "LICENSE" }
+keywords = ["rendering", "engine", "tile set", "top-down"]
+authors = [
+    { name = "Joshua Hegedus", email = "josh.hegedus@outlook.com" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "License :: OSI Approved :: MIT License",
+]
+
+dependencies = [
+    "pygame-ce"
+]
+
+[project.urls]
+Homepage = "https://github.com/lsc-jh/tileforge"
+Repository = "https://github.com/lsc-jh/tileforge"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

tileforge-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tileforge-0.1.1/src/tileforge/__init__.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: 2026-present Joshua Hegedus <josh.hegedus@outlook.com>
+#
+# SPDX-License-Identifier: MIT
+
+from .tileset import Tileset
+from .renderer import Renderer
+from .map import Map
+
+__all__ = ["Tileset", "Renderer", "Map"]

tileforge-0.1.1/src/tileforge/lib.py

@@ -0,0 +1,4 @@
+from typing import Callable
+
+Layer = list[list[tuple[int, int]]]
+DrawCallback = Callable[[int, int, int, int], None]

tileforge-0.1.1/src/tileforge/map.py

@@ -0,0 +1,61 @@
+from .lib import Layer
+from .tileset import Tileset
+
+
+class Map:
+    def __init__(self, width: int, height: int):
+        self.__layer_count = 0
+        self.__layers: list[Layer] = []
+        self.__width = width
+        self.__height = height
+
+    @property
+    def width(self) -> int:
+        return self.__width
+
+    @property
+    def height(self) -> int:
+        return self.__height
+
+    @property
+    def layers(self) -> list[Layer]:
+        return self.__layers
+
+    def set_layer_count(self, count: int) -> None:
+        if count < self.__layer_count:
+            self.__layers = self.__layers[:count]
+        else:
+            for _ in range(count - self.__layer_count):
+                self.__layers.append([[(0, 0) for _ in range(self.__width)] for _ in range(self.__height)])
+
+        self.__layer_count = count
+
+    def set_layers(self, layers: list[Layer]) -> None:
+        self.__layers = layers
+        self.__layer_count = len(layers)
+
+    def add_layer(self) -> None:
+        self.set_layer_count(self.__layer_count + 1)
+
+    def cell_has_property(self, tileset: Tileset, pos: tuple[int, int], property_id: int) -> bool:
+        """Check if any tile in the cell at (x, y) across all layers has the specified property."""
+        x, y = pos
+        for layer in self.__layers:
+            if y >= len(layer) or x >= len(layer[y]):
+                continue
+            index, _ = layer[y][x]
+            if tileset.has_property(index, property_id):
+                return True
+        return False
+
+    def __getitem__(self, item: tuple[int, int, int]) -> tuple[int, int]:
+        layer, x, y = item
+        if layer >= self.__layer_count or x >= self.__width or y >= self.__height:
+            raise IndexError("Layer, x, or y index out of bounds")
+        return self.__layers[layer][y][x]
+
+    def __setitem__(self, key: tuple[int, int, int], value: tuple[int, int]) -> None:
+        layer, x, y = key
+        if layer >= self.__layer_count or x >= self.__width or y >= self.__height:
+            raise IndexError("Layer, x, or y index out of bounds")
+        self.__layers[layer][y][x] = value

tileforge-0.1.1/src/tileforge/renderer.py

@@ -0,0 +1,47 @@
+from .lib import DrawCallback
+from .tileset import Tileset
+from .map import Map
+import pygame
+from pygame import Surface
+
+
+class Renderer:
+    def __init__(self, tileset: Tileset, map_layout: Map, render_scale: int = 1):
+        self.__render_scale = render_scale
+        self.__tileset = tileset
+        self.__tiles = self.__tileset.get_scaled_tiles(render_scale)
+        self.__map = map_layout
+
+    def set_render_scale(self, new_scale: int):
+        self.__render_scale = new_scale
+        self.__tiles = self.__tileset.get_scaled_tiles(new_scale)
+
+    @property
+    def tiles(self) -> list[Surface]:
+        return self.__tiles
+
+    @property
+    def render_tile_size(self) -> int:
+        return self.__tileset.tile_size * self.__render_scale
+
+    def render(self, surface: Surface, offset: tuple[int, int] = (0, 0), callback: DrawCallback | None = None) -> None:
+        offset_x, offset_y = offset
+        for y in range(self.__map.height):
+            for x in range(self.__map.width):
+                draw_x = x * self.render_tile_size + offset_x
+                draw_y = y * self.render_tile_size + offset_y
+
+                for layer in self.__map.layers:
+                    if y >= len(layer) or x >= len(layer[y]):
+                        continue
+                    index, rotation = layer[y][x]
+                    if index >= len(self.__tiles):
+                        continue
+                    tile = pygame.transform.rotate(self.__tiles[index], -90 * rotation)
+                    surface.blit(tile, (draw_x, draw_y))
+
+                if callback:
+                    try:
+                        callback(x, y, draw_x, draw_y)
+                    except Exception as e:
+                        print(f"Error in callback for tile ({x}, {y}): {e}")

tileforge-0.1.1/src/tileforge/tileset.py

@@ -0,0 +1,87 @@
+import pygame
+
+
+class Tileset:
+    def __init__(self, path: str, tile_size: int):
+        self.__path = path
+        self.__tile_size = tile_size
+        self.tiles: list[pygame.Surface] = []
+        self.__tile_properties: dict[int, set[int]] = {}
+
+    @property
+    def tile_size(self) -> int:
+        return self.__tile_size
+
+    @property
+    def path(self) -> str:
+        return self.__path
+
+    @property
+    def all_properties(self) -> dict[int, set[int]]:
+        return self.__tile_properties
+
+    def __load_tileset(self):
+        image = pygame.image.load(self.__path).convert_alpha()
+        tiles = []
+        w, h = image.get_size()
+
+        for y in range(0, h - self.__tile_size + 1, self.__tile_size):
+            for x in range(0, w - self.__tile_size + 1, self.__tile_size):
+                tile = image.subsurface((x, y, self.__tile_size, self.__tile_size))
+                tiles.append(tile)
+
+        empty_tile = pygame.Surface((self.__tile_size, self.__tile_size), pygame.SRCALPHA)
+        tiles.insert(0, empty_tile)
+
+        return tiles
+
+    def load(self):
+        self.tiles = self.__load_tileset()
+
+    def get_scaled_tiles(self, scale: int) -> list[pygame.Surface]:
+        return [pygame.transform.scale(tile, (self.__tile_size * scale, self.__tile_size * scale)) for tile in
+                self.tiles]
+
+    def has_property(self, tile_index: int, property_id: int) -> bool:
+        return tile_index in self.__tile_properties.get(property_id, set())
+
+    def serialize_properties(self):
+        return {str(index): list(props) for index, props in self.__tile_properties.items()}
+
+    def deserialize_properties(self, properties: dict[str, list[int]]):
+        self.__tile_properties = {int(index): set(props) for index, props in properties.items()}
+
+    def set_properties(self, properties: dict[int, set[int]]):
+        self.__tile_properties = properties
+
+    def set_property(self, tile_index: int, property_id: int):
+        if property_id not in self.__tile_properties:
+            self.__tile_properties[property_id] = set()
+        self.__tile_properties[property_id].add(tile_index)
+
+    def remove_property(self, tile_index: int, property_id: int):
+        if property_id in self.__tile_properties:
+            self.__tile_properties[property_id].discard(tile_index)
+            if not self.__tile_properties[property_id]:
+                del self.__tile_properties[property_id]
+
+    def toggle_property(self, tile_index: int, property_id: int):
+        if property_id not in self.__tile_properties:
+            self.__tile_properties[property_id] = set()
+        if tile_index in self.__tile_properties[property_id]:
+            self.__tile_properties[property_id].remove(tile_index)
+            if not self.__tile_properties[property_id]:
+                del self.__tile_properties[property_id]
+        else:
+            self.__tile_properties[property_id].add(tile_index)
+
+    def get_properties(self, property_id: int) -> set[int]:
+        return self.__tile_properties.get(property_id, set())
+
+    def set_tile_size(self, new_size: int):
+        self.__tile_size = new_size
+        self.tiles = self.__load_tileset()
+
+    def set_path(self, new_path: str):
+        self.__path = new_path
+        self.tiles = self.__load_tileset()

tileforge-0.1.1/src/tileforge.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: tileforge
+Version: 0.1.1
+Summary: A pygame rendering engine for top-down tile sets.
+Author-email: Joshua Hegedus <josh.hegedus@outlook.com>
+License: MIT License
+        
+        Copyright (c) 2026-present Joshua Hegedus <josh.hegedus@outlook.com>
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+        associated documentation files (the "Software"), to deal in the Software without restriction, including
+        without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+        following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial
+        portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+        LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+        EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+        IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+        USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/lsc-jh/tileforge
+Project-URL: Repository, https://github.com/lsc-jh/tileforge
+Keywords: rendering,engine,tile set,top-down
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame-ce
+Dynamic: license-file
+
+# Tile Forge
+
+This is a package for rendering top-down maps from a provided tile set image.
+
+## Class Diagram
+
+```mermaid
+---
+title: Class Relations
+---
+
+classDiagram
+    Renderer *-- Tileset
+    Renderer *-- Map
+    class Tileset {
+        + all_properties: dict[int, set[int]]
+        + tile_size: int
+        + path: str
+        + load()
+        + get_scaled_tiles(scale: int)
+        + has_property(tile_index: int, property_id: int): bool
+        + set_property(tile_index: int, property_index: int): void
+        + remove_property(tile_index: int, property_index: int): void
+        + toggle_property(tile_index: int, property_index: int): void
+    }
+
+    class Map {
+        + width: int
+        + height: int
+        + layers: list[Layer]
+        + set_layers(layers: list[Layer])
+        + set_layer_count(count: int)
+        + add_layer(layer: Layer)
+        + cell_has_property(tileset: Tileset, pos: tuple[int, int], property_id: int): bool
+    }
+
+    class Renderer {
+        - __map: Map
+        - __tileset: Tileset
+        + render_tile_size: int
+        + tiles: list[Surface]
+        + set_render_scale(scale: int)
+        + render(surface: Surface, offset: [int, int], callback): void
+    }
+```
+
+## Usage
+
+```python
+import pygame
+from tileforge import Tileset, Map, Renderer
+
+pygame.init()
+
+# You need a pygame surface to render the map, so make sure to initialize pygame first
+surface = pygame.Surface((640, 480))  # Create a surface to render on
+
+# Load the tileset and map
+tileset = Tileset("path/to/tileset.png", 32)
+tileset.load()
+
+# Create a map with the loaded tileset
+map = Map(10, 10)  # 10x10
+
+# Create a renderer and render the map
+renderer = Renderer(tileset, map)
+renderer.render(surface)
+```

tileforge-0.1.1/src/tileforge.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/tileforge/__init__.py
+src/tileforge/lib.py
+src/tileforge/map.py
+src/tileforge/renderer.py
+src/tileforge/tileset.py
+src/tileforge.egg-info/PKG-INFO
+src/tileforge.egg-info/SOURCES.txt
+src/tileforge.egg-info/dependency_links.txt
+src/tileforge.egg-info/requires.txt
+src/tileforge.egg-info/top_level.txt
+tests/test_tileset.py

tileforge-0.1.1/src/tileforge.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tileforge-0.1.1/src/tileforge.egg-info/requires.txt

@@ -0,0 +1 @@
+pygame-ce

tileforge-0.1.1/src/tileforge.egg-info/top_level.txt

@@ -0,0 +1 @@
+tileforge

tileforge-0.1.1/tests/test_tileset.py

@@ -0,0 +1,118 @@
+import pytest
+import pygame
+
+from tileforge import Tileset
+
+
+@pytest.fixture(scope="module", autouse=True)
+def pygame_init():
+    pygame.init()
+    pygame.display.set_mode((1, 1))
+    yield
+    pygame.quit()
+
+
+@pytest.fixture
+def mock_tileset(monkeypatch):
+    tile_size = 8
+    surface = pygame.Surface((16, 16), pygame.SRCALPHA)
+
+    def mock_load(path):
+        return surface
+
+    monkeypatch.setattr(pygame.image, "load", mock_load)
+
+    ts = Tileset("fake_path.png", tile_size)
+    ts.load()
+    return ts
+
+
+def test_load_tiles_count(mock_tileset):
+    assert len(mock_tileset.tiles) == 5
+
+
+def test_empty_tile_is_first(mock_tileset):
+    first_tile = mock_tileset.tiles[0]
+    assert first_tile.get_size() == (mock_tileset.tile_size, mock_tileset.tile_size)
+
+
+def test_scaled_tiles(mock_tileset):
+    scale = 2
+    scaled = mock_tileset.get_scaled_tiles(scale)
+
+    assert len(scaled) == len(mock_tileset.tiles)
+    for tile in scaled:
+        assert tile.get_size() == (
+            mock_tileset.tile_size * scale,
+            mock_tileset.tile_size * scale,
+        )
+
+
+def test_set_and_has_property(mock_tileset):
+    mock_tileset.set_property(100, 1)
+
+    assert mock_tileset.has_property(100, 1)
+    assert not mock_tileset.has_property(200, 1)
+
+
+def test_remove_property(mock_tileset):
+    mock_tileset.set_property(1, 100)
+    mock_tileset.remove_property(1, 100)
+
+    assert not mock_tileset.has_property(1, 100)
+
+
+def test_toggle_property(mock_tileset):
+    mock_tileset.toggle_property(1, 100)
+    assert mock_tileset.has_property(1, 100)
+
+    mock_tileset.toggle_property(1, 100)
+    assert not mock_tileset.has_property(1, 100)
+
+
+def test_get_properties(mock_tileset):
+    mock_tileset.set_property(1, 100)
+    mock_tileset.set_property(2, 100)
+
+    props = mock_tileset.get_properties(100)
+    assert props == {1, 2}
+
+
+def test_serialize_deserialize(mock_tileset):
+    mock_tileset.set_property(1, 100)
+    mock_tileset.set_property(2, 200)
+
+    data = mock_tileset.serialize_properties()
+
+    new_ts = Tileset("fake_path.png", 8)
+    new_ts.deserialize_properties(data)
+
+    assert new_ts.has_property(1, 100)
+    assert new_ts.has_property(2, 200)
+
+
+def test_set_tile_size(monkeypatch):
+    surface = pygame.Surface((16, 16), pygame.SRCALPHA)
+
+    monkeypatch.setattr(pygame.image, "load", lambda _: surface)
+
+    ts = Tileset("fake.png", 8)
+    ts.load()
+
+    ts.set_tile_size(4)
+
+    assert ts.tile_size == 4
+    assert len(ts.tiles) == 17
+
+
+def test_set_path(monkeypatch):
+    surface = pygame.Surface((16, 16), pygame.SRCALPHA)
+
+    monkeypatch.setattr(pygame.image, "load", lambda _: surface)
+
+    ts = Tileset("old.png", 8)
+    ts.load()
+
+    ts.set_path("new.png")
+
+    assert ts.path == "new.png"