tileforge 0.1.0__py3-none-any.whl

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/lib.py

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

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/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/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.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: tileforge
+Version: 0.1.0
+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.8
+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.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+tileforge/__init__.py,sha256=EtlTnzgZN6YJuqJMsEEQdqHBBB4kT2Gx826TO4u8fwU,238
+tileforge/lib.py,sha256=cA_q4zyT84VvihY7HplIixdTFkXhfenS1hBlgCziJ7c,117
+tileforge/map.py,sha256=Q18uS27OoKfI0iaSD4vvKU0XDiYQJX-xlnjz0tUYng0,2115
+tileforge/renderer.py,sha256=TqrTdukb2iEQEI8JYXKwesU5DXf5mPKINElsPxX8cAw,1773
+tileforge/tileset.py,sha256=zZTMjZe7meX4TcZAi-4ZHnTWRWePUujX7iO2G3g5edc,3279
+tileforge-0.1.0.dist-info/licenses/LICENSE,sha256=LichDYrCYbWRnHQbTTMx4cgHTvt4FM_tF7P5gPD9awk,1106
+tileforge-0.1.0.dist-info/METADATA,sha256=MxiDOah5UCwUAcnukg9XtA_Z44A8gkTpxJ1IoWaq4OM,3800
+tileforge-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+tileforge-0.1.0.dist-info/top_level.txt,sha256=j7NsqiR_3MN07Y013H_-Y3ypByKRsXWRepz6O9hT0iY,10
+tileforge-0.1.0.dist-info/RECORD,,

tileforge-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tileforge-0.1.0.dist-info/licenses/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.0.dist-info/top_level.txt

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