mima-engine 0.2.2__tar.gz → 0.2.3__tar.gz

{mima_engine-0.2.2 → mima_engine-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mima-engine
-Version: 0.2.2
+Version: 0.2.3
 Summary: A game engine based on pygame.
 Author-email: Stephan Balduin <stephan.balduin@mailbox.org>
 Classifier: Programming Language :: Python :: 3

mima_engine-0.2.3/src/mima/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.2.3"
+
+from .core.engine import MimaEngine
+from .core.mode_engine import MimaModeEngine

{mima_engine-0.2.2 → mima_engine-0.2.3}/src/mima/backend/pygame_assets.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import csv
 import logging
 import os
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional
 
 import pygame
 
@@ -21,9 +21,10 @@ LOG = logging.getLogger(__name__)
 class PygameAssets:
     def __init__(self, rtc: RuntimeConfig, init_file: str):
         self.rtc = rtc
-        self._sprites: Dict[str, pygame.Surface] = {}
+        self._images: Dict[str, pygame.Surface] = {}
         self._tilesets: Dict[str, TiledTileset] = {}
         self._templates: Dict[str, TiledTemplate] = {}
+        self._sprite_sheets: Dict[str, Dict[Any]] = {}
         self._maps: Dict[str, TiledMap] = {}
         self._music: Dict[str, str] = {}
         self._sound: Dict[str, str] = {}
@@ -145,17 +146,17 @@ class PygameAssets:
         # print(name, filename)
 
         possible_name = os.path.split(filename)[-1][:-4]
-        if possible_name in self._sprites:
+        if possible_name in self._images:
             LOG.warning(
                 "Sprite '%s' is possibly already loaded with name %s.",
                 filename,
                 possible_name,
             )
-        elif name in self._sprites:
+        elif name in self._images:
             LOG.debug("Sprite '%s' already loaded. Skipping.")
             return name
 
-        self._sprites[name] = self._load_sprite_from_disk(filename)
+        self._images[name] = self._load_sprite_from_disk(filename)
 
         return name
 
@@ -182,7 +183,59 @@ class PygameAssets:
         elif name in self._tilesets:
             LOG.debug("Tileset at '%s' already loaded. Skipping", filename)
             return name
-        self._tilesets[name] = TiledTileset(name, filename)
+        ts = TiledTileset(name, filename)
+        self._tilesets[name] = ts
+
+        # Load sprite sheets
+        for tile in ts.tiles:
+            if not tile.sprite_name:
+                continue
+
+            self._sprite_sheets.setdefault(tile.sprite_name, {})
+            data = {
+                "duration": [],
+                "ox": [],
+                "oy": [],
+                "image": [],
+                "width": [],
+                "height": [],
+            }
+            if tile.animated:
+                for frame in tile._frames:
+                    data["duration"].append(frame.duration)
+                    data["ox"].append(frame.frame_id % ts.columns)
+                    data["oy"].append(frame.frame_id // ts.columns)
+                    data["image"].append(ts.image_name)
+                    data["width"].append(ts.tile_width)
+                    data["height"].append(ts.tile_height)
+            else:
+                data["duration"].append(1000)
+                data["ox"].append(tile.tile_id % ts.columns)
+                data["oy"].append(tile.tile_id // ts.columns)
+                data["image"].append(ts.image_name)
+                data["width"].append(ts.tile_width)
+                data["height"].append(ts.tile_height)
+
+            self._sprite_sheets[tile.sprite_name].setdefault(
+                tile.graphic_state, {}
+            )
+            self._sprite_sheets[tile.sprite_name][tile.graphic_state][
+                tile.facing_direction
+            ] = data
+            LOG.debug(
+                "%s",
+                {
+                    "operation": "add frames",
+                    "image": ts.image_name,
+                    "sprite": tile.sprite_name,
+                    "graphic_state": tile.graphic_state.name,
+                    "direction": tile.facing_direction.name,
+                    "frame_data": data,
+                },
+            )
+
+        # for sprite_name in ts.sprite_names:
+        #     self._sprites[sprite_name] = {}
         return name
 
     def _load_template(self, name, filename=None):
@@ -191,7 +244,7 @@ class PygameAssets:
 
         if not os.path.isfile(filename):
             filename = os.path.join(
-                self._data_path, "templates", os.path.split(filename)[-1]
+                self.data_path, "templates", os.path.split(filename)[-1]
             )
 
         possible_name = os.path.split(filename)[-1][:-3]
@@ -287,13 +340,18 @@ class PygameAssets:
                 name_color = f"{name}_color"
             else:
                 name_color = name
-            return self._sprites.get(name_color, self._sprites[name])
+            return self._images.get(name_color, self._images[name])
+
+    def get_sprite_data(self, sprite_id):
+        if not sprite_id:
+            return {}
+        return self._sprite_sheets[sprite_id]
 
     def new_map(self, name, tilemap: Tilemap):
         self._maps[name] = tilemap
 
     def new_sprite(self, name, surface: pygame.Surface):
-        self._sprites[name] = surface
+        self._images[name] = surface
 
     def get_tileset(self, name):
         if name not in self._tilesets:

{mima_engine-0.2.2 → mima_engine-0.2.3}/src/mima/backend/pygame_backend.py

@@ -464,8 +464,11 @@ class PygameBackend:
             )
             idx += 1
 
-    def draw_pixel(self, px: float, py: float, color: Color):
-        self.display.set_at((int(px), int(py)), color.getRGB())
+    def draw_pixel(
+        self, px: float, py: float, color: Color, camera_name=C_DISPLAY
+    ):
+        display = self._cameras[camera_name].view
+        display.set_at((int(px), int(py)), color.getRGB())
 
     def draw_camera(self, name, px, py, scale):
         self.display.blit(

{mima_engine-0.2.2/src/mima → mima_engine-0.2.3/src/mima/core}/collision.py

@@ -3,17 +3,17 @@ from __future__ import annotations
 import math
 from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Tuple
 
-from .maps.tilemap import Tilemap
-from .types.direction import Direction
-from .types.graphic_state import GraphicState, Until
-from .types.nature import Nature
-from .types.object import ObjectType
-from .types.tile_collision import TileCollision
+from ..maps.tilemap import Tilemap
+from ..types.direction import Direction
+from ..types.graphic_state import GraphicState, Until
+from ..types.nature import Nature
+from ..types.object import ObjectType
+from ..types.tile_collision import TileCollision
 
 if TYPE_CHECKING:
     # from .engine import MimaEngine
-    from .objects.dynamic import Dynamic
-    from .states.quest import Quest
+    from ..objects.dynamic import Dynamic
+    from ..states.quest import Quest
 
     # from .view.view import View
 
@@ -35,9 +35,7 @@ def check_object_to_map_collision(
 
     collided_with_map = False
     if obj.solid_vs_map:
-        if collision_with_map(
-            tilemap, left, right, top, bottom, layer, collision
-        ):
+        if collision_with_map(tilemap, left, right, top, bottom, layer, collision):
             # On rare occasions, the object might be pushed towards
             # the wall, i.e. old and new pos are equal
             # Decide depending on the decimal part of the position
@@ -68,9 +66,7 @@ def check_object_to_map_collision(
         top = new_py + obj.hitbox_py
         bottom = top + obj.hitbox_height
 
-        if collision_with_map(
-            tilemap, left, right, top, bottom, layer, collision
-        ):
+        if collision_with_map(tilemap, left, right, top, bottom, layer, collision):
             # See comment above
             if new_py == obj.py:
                 decimal_dif = new_py - int(new_py)
@@ -287,9 +283,7 @@ def add_to_collision_chunk(
     return chunk_ids
 
 
-def _test_chunk_position(
-    collision_chunks, obj, px, py, chunk_size, chunks_per_row
-):
+def _test_chunk_position(collision_chunks, obj, px, py, chunk_size, chunks_per_row):
     chidx = _chunk_index(px, py, chunk_size, chunks_per_row)
     collision_chunks.setdefault(chidx, [])
 

mima_engine-0.2.3/src/mima/core/database.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict
+
+from ..objects.animated_sprite import AnimatedSprite
+from ..types.damage import Damage
+
+if TYPE_CHECKING:
+    from .engine import MimaEngine
+
+LOG = logging.getLogger(__name__)
+
+
+class Database:
+    engine: MimaEngine
+
+    def __init__(self):
+        self._cache = {}
+        self._known_locale = ""
+        self._active_sprites = []
+
+    def get_usable_data(self, usable_id) -> Dict[str, Any]:
+        if usable_id in self._cache:
+            return self._cache[usable_id]
+
+        data = {}
+        tpl = self.engine.assets.get_template(usable_id)
+
+        data["usable_id"] = tpl.get_string("usable_id")
+        data["name"] = tpl.get_string(f"display_name_{self.engine.rtc.locale}")
+        data["description"] = tpl.get_string(f"description_{self.engine.rtc.locale}")
+        data["sprite_name"] = tpl.get_string("sprite_name")
+        data["dtype"] = Damage[tpl.get_string("dtype", "body").upper()]
+        for pid, prop in tpl.properties.items():
+            if not pid.startswith("attr_"):
+                continue
+            _, attr = pid.split("_", 1)
+            data[attr] = tpl.get(pid)
+        # data["attr_price"] = tpl.get_int("attr_price")
+        # data["attr_swing_timer"] = tpl.get_float("attr_swing_timer")
+        # data["attr_damage"] = tpl.get_int("attr_damage")
+        # data["attr_health_cost"] = tpl.get_int("attr_health_cost")
+        # data["attr_magic_cost"] = tpl.get_int("attr_magic_cost")
+        # data["attr_stamina_cost"] = tpl.get_int("attr_stamina_cost")
+        # data["attr_bomb_cost"] = tpl.get_int("attr_bomb_cost")
+        # data["attr_arrow_cost"] = tpl.get_int("attr_arrow_cost")
+
+        self._cache[usable_id] = data
+        return data
+
+    def get_object_data(self, object_id) -> Dict[str, Any]:
+        return {}
+
+    def get_sprite(self, sprite_id):
+        sprite = AnimatedSprite(sprite_id)
+        self._active_sprites.append(sprite)
+        return sprite

{mima_engine-0.2.2/src/mima → mima_engine-0.2.3/src/mima/core}/engine.py

@@ -4,30 +4,32 @@ import logging
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
-from .backend.pygame_assets import PygameAssets
-from .backend.pygame_audio import PygameAudio
-from .backend.pygame_backend import PygameBackend
-from .backend.pygame_events import PygameUserInput
-from .maps.template import Template
-from .maps.tilemap import Tilemap
-from .objects.animated_sprite import AnimatedSprite
-from .objects.creature import Creature
-from .objects.dynamic import Dynamic
-from .objects.loader import ObjectLoader
-from .objects.sprite import Sprite
-from .scripts import Command, ScriptProcessor
-from .states.memory import Memory
-from .states.quest import Quest
-from .types.gate_color import GateColor
-from .types.mode import Mode
-from .types.player import Player
-from .usables.item import Item
-from .util import RuntimeConfig
-from .util.logging import install_trace_logger
-from .view.camera import Camera
+from ..backend.pygame_assets import PygameAssets
+from ..backend.pygame_audio import PygameAudio
+from ..backend.pygame_backend import PygameBackend
+from ..backend.pygame_events import PygameUserInput
+from ..maps.template import Template
+from ..maps.tilemap import Tilemap
+from ..objects.animated_sprite import AnimatedSprite
+from ..objects.creature import Creature
+from ..objects.dynamic import Dynamic
+from ..objects.loader import ObjectLoader
+from ..objects.sprite import Sprite
+from ..scripts import Command, ScriptProcessor
+from ..states.memory import Memory
+from ..states.quest import Quest
+from ..types.gate_color import GateColor
+from ..types.mode import Mode
+from ..types.player import Player
+from ..usables.item import Item
+from ..usables.weapon import Weapon
+from ..util import RuntimeConfig
+from ..util.logging import install_trace_logger
+from ..view.camera import Camera
 
 # from .view.game_mode import GameMode
-from .view.mima_view import MimaView
+from ..view.mima_view import MimaView
+from .database import Database
 
 # from .view.scene import Scene
 
@@ -49,10 +51,8 @@ class MimaEngine(ABC):
         self.rtc = RuntimeConfig(config_path, default_config)
         install_trace_logger()
 
-        self.backend: PygameBackend = PygameBackend(
-            self.rtc, init_file, platform
-        )
-
+        self.backend: PygameBackend = PygameBackend(self.rtc, init_file, platform)
+        self.db: Database
         self._caption: str = caption
         self.seconds_total: float = 0.0
         self.app_fps: float = 0.0
@@ -86,6 +86,7 @@ class MimaEngine(ABC):
         AnimatedSprite.engine = self
         Camera.engine = self
         Command.engine = self
+        Database.engine = self
         Dynamic.engine = self
         # GameMode.engine = self
         Item.engine = self
@@ -100,6 +101,7 @@ class MimaEngine(ABC):
         MimaView.engine = self
 
         self.script = ScriptProcessor()
+        self.db = Database()
         self.backend.init(
             keyboard_map=self.rtc.get_keyboard_map(),
             joystick_map=self.rtc.get_joystick_map(),
@@ -124,8 +126,7 @@ class MimaEngine(ABC):
         if self.on_user_create():
             while self.backend.keep_running():
                 self.backend.set_caption(
-                    f"{self._caption} ({self.game_fps:.2f}/"
-                    f"{self.app_fps:.2f} fps)"
+                    f"{self._caption} ({self.game_fps:.2f}/" f"{self.app_fps:.2f} fps)"
                 )
                 self.backend.process_events()
 
@@ -159,10 +160,7 @@ class MimaEngine(ABC):
                     app_frames = 0
                     app_seconds -= 1.0
 
-            print(
-                f"App/Game Frames total: {app_frames_total}/"
-                f"{game_frames_total}"
-            )
+            print(f"App/Game Frames total: {app_frames_total}/" f"{game_frames_total}")
             print(f"Seconds total: {self.seconds_total:.3f}")
             print(
                 "Average App/Game FPS: "
@@ -200,9 +198,24 @@ class MimaEngine(ABC):
     def get_map(self, map_name: str):
         return self.backend.assets.get_map(map_name)
 
-    def load_item(self, item: Item):
-        LOG.debug(f"Loading item  {item.name}.")
-        self.memory.items[item.name] = item
+    def load_usable(self, item: Item, item_id) -> None:
+        LOG.debug("Loading usable %s.", item_id)
+        item.init(self.db.get_usable_data(item_id))
+        self.memory.items[item_id] = item
+
+    # def load_weapon(self, weapon: Weapon, weapon_id: str) -> None:
+    #     LOG.debug("Loading weapon %s.", weapon_id)
+    #     weapon.init(self.db.get_weapon_data(weapon_id))
+    #     self.memory.items[weapon_id] = weapon
+
+    # def load_item(self, item: Item, item_id: str) -> None:
+    #     LOG.debug("Loading item %s.", item_id)
+    #     item.init(self.db.get_item_data(item_id))
+    #     self.memory.items[item_id] = item
+
+    # def load_item(self, item: Item):
+    #     LOG.debug(f"Loading item  {item.name}.")
+    #     self.memory.items[item.name] = item
 
     def get_item(self, item_id: str):
         try:
@@ -263,9 +276,7 @@ class MimaEngine(ABC):
     def set_player(self, creature: Creature, player: Player = Player.P1):
         self.memory.player[player] = creature
 
-    def trigger_teleport(
-        self, active: bool = True, player: Player = Player.P1
-    ):
+    def trigger_teleport(self, active: bool = True, player: Player = Player.P1):
         self.memory.teleport_active[player] = active
 
     def is_teleport_active(self, player: Player = Player.P1):
@@ -277,9 +288,7 @@ class MimaEngine(ABC):
     def is_dialog_active(self, player: Player = Player.P1):
         return self.memory.dialog_active[player]
 
-    def trigger_script(
-        self, active: bool = True, player: Player = Player.P1
-    ) -> None:
+    def trigger_script(self, active: bool = True, player: Player = Player.P1) -> None:
         self.memory.script_active[player] = active
 
     def is_script_active(self, player: Player = Player.P1) -> bool:
@@ -328,10 +337,7 @@ class MimaEngine(ABC):
 
     @dialog_active.setter
     def dialog_active(self, val):
-        print(
-            "dialog_active is deprecated; use "
-            "'trigger_dialog(active)' instead."
-        )
+        print("dialog_active is deprecated; use " "'trigger_dialog(active)' instead.")
         self.memory.dialog_active = val
 
     @property

{mima_engine-0.2.2/src/mima → mima_engine-0.2.3/src/mima/core}/mode_engine.py

@@ -1,13 +1,13 @@
 import logging
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
+from ..states.game_state import GameState
+from ..types.keys import Key as K
+from ..types.mode import Mode
+from ..types.nature import Nature
+from ..types.player import Player
+from ..view.mima_mode import MimaMode
 from .engine import MimaEngine
-from .states.game_state import GameState
-from .types.keys import Key as K
-from .types.mode import Mode
-from .types.nature import Nature
-from .types.player import Player
-from .view.mima_mode import MimaMode
 
 # from .view.mima_scene import MimaScene
 LOG = logging.getLogger(__name__)
@@ -22,9 +22,7 @@ class MimaModeEngine(MimaEngine):
         platform="PC",
         caption: str = "MimaEngine",
     ):
-        super().__init__(
-            init_file, config_path, default_config, platform, caption
-        )
+        super().__init__(init_file, config_path, default_config, platform, caption)
 
         self.modes: Dict[Mode, MimaMode] = {}
         self.mode: Optional[MimaMode] = None
@@ -69,9 +67,7 @@ class MimaModeEngine(MimaEngine):
         self.mode.load()
 
     def return_mode(self):
-        LOG.debug(
-            "Returning to previous mode. Stack: %s", str(self.mode_stack)
-        )
+        LOG.debug("Returning to previous mode. Stack: %s", str(self.mode_stack))
         self.mode_stack.pop()
         self.mode = self.modes[self.mode_stack[-1]]
         self.mode.load()

{mima_engine-0.2.2/src/mima → mima_engine-0.2.3/src/mima/core}/scene_engine.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Dict, List, Optional, Union, Any
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from .engine import MimaEngine
 from .states.game_state import GameState
@@ -18,9 +18,7 @@ class MimaSceneEngine(MimaEngine):
         platform: str = "PC",
         caption: str = "MimaEngine",
     ):
-        super().__init__(
-            init_file, config_path, default_config, platform, caption
-        )
+        super().__init__(init_file, config_path, default_config, platform, caption)
 
         self.scene_stack: List[str] = []
         self._scenes: Dict[str, Scene] = {}
@@ -46,9 +44,7 @@ class MimaSceneEngine(MimaEngine):
             if self._current_scene.autosave:
                 for quest in self.quests:
                     for obj in self.scene.dynamics:
-                        quest.on_interaction(
-                            self.scene.dynamics, obj, Nature.SAVE
-                        )
+                        quest.on_interaction(self.scene.dynamics, obj, Nature.SAVE)
                     quest.save_state()
         if self.keys.new_key_press(K.SELECT):
             self.game_state.save_to_disk()

mima_engine-0.2.3/src/mima/maps/template.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, Optional, Union
+
+from ..util.functions import strtobool
+from ..util.property import Property
+
+if TYPE_CHECKING:
+    from ..engine import MimaEngine
+
+
+class Template:
+    engine: MimaEngine
+
+    def __init__(self, name: str):
+        self.name: str = name
+        self.properties: Dict[str, Property] = {}
+
+    def get_string(self, key: str, default_val: str = "") -> str:
+        if key in self.properties:
+            return self.properties[key].value
+        else:
+            return default_val
+
+    def get_int(self, key: str, default_val: int = 0) -> int:
+        if key in self.properties:
+            return int(self.properties[key].value)
+        else:
+            return default_val
+
+    def get_float(self, key: str, default_val: float = 0.0) -> float:
+        if key in self.properties:
+            return float(self.properties[key].value)
+        else:
+            return default_val
+
+    def get_bool(self, key: str, default_val: bool = False) -> bool:
+        if key in self.properties:
+            return bool(strtobool(self.properties[key].value))
+        else:
+            return default_val
+
+    def get(
+        self, key: str, default_val: Optional[str, int, float, bool] = None
+    ) -> Union[str, int, float, bool]:
+
+        if key in self.properties:
+            if self.properties[key].dtype == "str":
+                if default_val is None:
+                    return self.get_string(key)
+                return self.get_string(key, default_val)
+            if self.properties[key].dtype == "int":
+                if default_val is None:
+                    return self.get_int(key)
+                return self.get_int(key, int(default_val))
+            if self.properties[key].dtype == "float":
+                if default_val is None:
+                    return self.get_float(key)
+                return self.get_float(key, float(default_val))
+            if self.properties[key].dtype == "bool":
+                if default_val is None:
+                    return self.get_bool(key)
+                elif not isinstance(default_val, bool):
+                    msg = (
+                        "Trying to access a bool value but default value "
+                        f"{default_val} is of type {type(default_val)}"
+                    )
+                    raise TypeError(msg)
+                return self.get_bool(key, default_val)
+
+        return default_val

{mima_engine-0.2.2 → mima_engine-0.2.3}/src/mima/maps/tiled/tiled_object.py

@@ -47,7 +47,7 @@ class TiledObject(Template):
                 name="tileset_name", dtype="str", value=tpl.tileset_name
             )
             self.properties["image_name"] = Property(
-                name="image_name", dtype="str", value=ts.sprite_name
+                name="image_name", dtype="str", value=""
             )
             self.properties["sprite_offset_x"] = Property(
                 name="sprite_offset_x",

{mima_engine-0.2.2 → mima_engine-0.2.3}/src/mima/maps/tiled/tiled_tileset.py

@@ -33,14 +33,19 @@ class TiledTileset(Tileset):
 
         LOG.debug("Loading image properties ...")
         image = root.findall("image")[0]
-        self.sprite_name: str = os.path.split(image.attrib["source"])[-1][:-4]
+        self.image_name: str = os.path.split(image.attrib["source"])[-1][:-4]
         self.sprite_width: int = int(image.attrib["width"])
         self.sprite_height: int = int(image.attrib["height"])
 
         LOG.debug("Loading tiles ...")
         tiles = root.findall("tile")
-        
+
         for tile in tiles:
-            self.tiles.append(TiledTile(tile))
-            if self.tiles[-1].animated:
-                self.animated_tiles.append(self.tiles[-1])
+            t_obj = TiledTile(tile)
+            self.tiles.append(t_obj)
+            if t_obj.animated:
+                self.animated_tiles.append(t_obj)
+            if t_obj.sprite_name:
+                self.sprite_names.setdefault(t_obj.sprite_name, []).append(
+                    t_obj.tile_id
+                )

{mima_engine-0.2.2 → mima_engine-0.2.3}/src/mima/maps/tilemap.py

@@ -64,12 +64,8 @@ class Tilemap(Template):
             if layer.layer_pos != layer_pos:
                 continue
 
-            layer_ox = (
-                layer.layer_ox - math.floor(layer.layer_ox)
-            ) * self.tile_width
-            layer_oy = (
-                layer.layer_oy - math.floor(layer.layer_oy)
-            ) * self.tile_height
+            layer_ox = (layer.layer_ox - math.floor(layer.layer_ox)) * self.tile_width
+            layer_oy = (layer.layer_oy - math.floor(layer.layer_oy)) * self.tile_height
 
             layer_visible_tiles_sx = int(visible_tiles_sx)
             layer_visible_tiles_sy = int(visible_tiles_sy)
@@ -81,9 +77,7 @@ class Tilemap(Template):
 
             # Draw visible tiles of the map
             for x in range(layer_visible_tiles_sx, int(visible_tiles_ex) + 2):
-                for y in range(
-                    layer_visible_tiles_sy, int(visible_tiles_ey) + 2
-                ):
+                for y in range(layer_visible_tiles_sy, int(visible_tiles_ey) + 2):
                     tile_index = layer.get_index(
                         int(x + math.floor(ox)), int(y + math.floor(oy))
                     )
@@ -103,7 +97,7 @@ class Tilemap(Template):
                     self.engine.backend.draw_partial_sprite(
                         math.floor(x * self.tile_width - tile_ox + layer_ox),
                         math.floor(y * self.tile_height - tile_oy + layer_oy),
-                        info.tileset.sprite_name,
+                        info.tileset.image_name,
                         sx * self.tile_width,
                         sy * self.tile_height,
                         self.tile_width,