mima-engine 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

mima/backend/touch_control_scheme_a.py

@@ -0,0 +1,126 @@
+import time
+
+import pygame
+
+from ..types.keys import Key as K
+from ..util.constants import DOUBLE_TAP_SPEED
+from ..util.input_defaults import BUTTONS, DEFAULT_TOUCHSCREEN_MAP
+
+
+class TouchControlSchemeA:
+
+    def __init__(self):
+
+        self._left_finger_tap_pos = 0.0
+        self._right_finger_tap_pos = 0.0
+
+        self._last_left_tap = 0.0
+        self._last_right_tap = 0.0
+
+    def handle_touch(self, event, width=1.0, height=1.0):
+        set_keys = []
+        unset_keys = []
+
+        tap_pos = pygame.Vector2(event.x * width, event.y * height)
+
+        if event.type == pygame.FINGERDOWN:
+            tap_time = time.time()
+            for key, area in DEFAULT_TOUCHSCREEN_MAP.items():
+
+                if (
+                    area[0][0] <= event.x < area[1][0]
+                    and area[0][1] <= event.y < area[1][1]
+                ):
+                    if key == K.P1_UP:
+                        self._left_finger_tap_pos = tap_pos
+                        if tap_time - self._last_left_tap < DOUBLE_TAP_SPEED:
+                            # print("Left Double Tap")
+                            set_keys.append(K.P1_SELECT)
+                        self._last_left_tap = tap_time
+                    elif key == K.P1_L:
+                        set_keys.append(K.P1_L)
+                    else:
+                        set_keys.append(key)
+                        self._right_finger_tap_pos = tap_pos
+                        self._last_right_tap = tap_time
+
+        if event.type == pygame.FINGERUP:
+            # release = time.time()
+            # finger_dist = (finger_pos - self._left_finger_tap_pos).length()
+
+            if event.x < 0.5:
+                # print(f"Left Finger Up: {finger_pos}")
+                # if (
+                #     SINGLE_TAP_MIN
+                #     < release - self._last_left_tap
+                #     < SINGLE_TAP_MAX
+                # ) and finger_dist < 2.5:
+                #     print("Left Single Tap")
+                #     # set_keys.append(K.START)
+
+                unset_keys.append(K.P1_SELECT)
+                unset_keys.append(K.P1_RIGHT)
+                unset_keys.append(K.P1_LEFT)
+                unset_keys.append(K.P1_UP)
+                unset_keys.append(K.P1_DOWN)
+                unset_keys.append(K.P1_L)
+                # print(
+                #     f"Left Finger moved {finger_dist} "
+                #     f"({release - self._last_left_tap} s)"
+                # )
+            else:
+                unset_keys.append(K.P1_START)
+                unset_keys.append(K.P1_A)
+                unset_keys.append(K.P1_B)
+                unset_keys.append(K.P1_Y)
+                unset_keys.append(K.P1_X)
+                unset_keys.append(K.P1_R)
+
+        if event.type == pygame.FINGERMOTION:
+            if event.x < 0.5:
+                vd = tap_pos - self._left_finger_tap_pos
+                unset_keys.append(K.P1_RIGHT)
+                unset_keys.append(K.P1_LEFT)
+                unset_keys.append(K.P1_UP)
+                unset_keys.append(K.P1_DOWN)
+                if abs(vd.x) > 2 * abs(vd.y):
+                    # Horizontal
+                    if vd.x > 5.0:
+                        set_keys.append(K.P1_RIGHT)
+                        unset_keys.append(K.P1_LEFT)
+                        unset_keys.append(K.P1_UP)
+                        unset_keys.append(K.P1_DOWN)
+                    elif vd.x < -5.0:
+                        set_keys.append(K.P1_LEFT)
+                        unset_keys.append(K.P1_RIGHT)
+                        unset_keys.append(K.P1_UP)
+                        unset_keys.append(K.P1_DOWN)
+                elif abs(vd.x) * 2 < abs(vd.y):
+                    # Vertical
+                    if vd.y > 5.0:
+                        unset_keys.append(K.P1_RIGHT)
+                        unset_keys.append(K.P1_LEFT)
+                        unset_keys.append(K.P1_UP)
+                        set_keys.append(K.P1_DOWN)
+                    elif vd.y < -5.0:
+                        unset_keys.append(K.P1_LEFT)
+                        unset_keys.append(K.P1_RIGHT)
+                        set_keys.append(K.P1_UP)
+                        unset_keys.append(K.P1_DOWN)
+                elif abs(vd.x) * 1.05 > abs(vd.y) or abs(vd.x) < 1.05 * abs(
+                    vd.y
+                ):
+                    if vd.x < 0:
+                        set_keys.append(K.P1_LEFT)
+                    elif vd.x > 0:
+                        set_keys.append(K.P1_RIGHT)
+                    if vd.y < 0:
+                        set_keys.append(K.P1_UP)
+                    elif vd.y > 0:
+                        set_keys.append(K.P1_DOWN)
+                self.vd = vd
+
+        return set_keys, unset_keys
+
+    def get_touch_state(self):
+        return {}

mima/backend/touch_control_scheme_b.py

@@ -0,0 +1,132 @@
+import time
+
+import pygame
+
+from ..types.keys import Key as K
+from ..util.constants import DOUBLE_TAP_SPEED
+from ..util.input_defaults import ALT_TOUCHSCREEN_MAP, BUTTONS
+
+
+class TouchControlSchemeB:
+
+    def __init__(self):
+
+        self.move_start_pos = pygame.Vector2()
+        self.move_pos = pygame.Vector2()
+        self.move_sy = 0.0
+        self.move_px = 0.0
+        self.move_py = 0.0
+        self._left_finger_tap_pos = 0.0
+        self._right_finger_tap_pos = 0.0
+
+        self._last_left_tap = 0.0
+        self._last_right_tap = 0.0
+        self._keys_active = {k: False for k in K}
+        self._state = {}
+        for key, conf in ALT_TOUCHSCREEN_MAP.items():
+            px, py = conf["pos"]
+            w, h = conf["size"]
+            self._state[key] = {
+                "rpx": px,
+                "rpy": py,
+                "rwidth": w,
+                "rheight": h,
+                "active": False,
+            }
+
+    def handle_touch(self, event, width=1.0, height=1.0):
+        set_keys = []
+        unset_keys = []
+
+        tap_pos = pygame.Vector2(event.x * width, event.y * height)
+        keys_active = {k: False for k in K}
+        # print(f"{event.x:.2f}, {event.y:.2f}", end="")
+        for key, conf in ALT_TOUCHSCREEN_MAP.items():
+            px, py = conf["pos"]
+            w, h = conf["size"]
+            area = [[px, py], [px + w, py + h]]
+
+            if (
+                area[0][0] <= event.x < area[1][0]
+                and area[0][1] <= event.y < area[1][1]
+            ):
+                if key == K.P1_UP:
+                    if event.type == pygame.FINGERDOWN:
+                        self.move_start_pos = pygame.Vector2(tap_pos)
+                        self.move_pos = pygame.Vector2(tap_pos)
+                        self._state[key]["rsx"] = event.x
+                        self._state[key]["rsy"] = event.y
+                        self._state[key]["rpx"] = event.x
+                        self._state[key]["rpy"] = event.y
+                    elif event.type == pygame.FINGERMOTION:
+                        self.move_pos = tap_pos
+                        self._state[key]["rpx"] = event.x
+                        self._state[key]["rpy"] = event.y
+
+                        vd = self.move_pos - self.move_start_pos
+                        if abs(vd.x) > 2 * abs(vd.y):
+                            # Horizontal
+                            if vd.x > 5.0:
+                                keys_active[K.P1_RIGHT] = True
+                                # print("..>", end="")
+                            elif vd.x < -5.0:
+                                keys_active[K.P1_LEFT] = True
+                                # print("..<", end="")
+                        elif abs(vd.x) * 2 < abs(vd.y):
+                            # Vertical
+                            if vd.y > 5.0:
+                                keys_active[K.P1_DOWN] = True
+                                # print("..v", end="")
+                            elif vd.y < -5.0:
+                                keys_active[K.P1_UP] = True
+                                # print("..^", end="")
+                        elif abs(vd.x) * 1.05 > abs(vd.y) or abs(
+                            vd.x
+                        ) < 1.05 * abs(vd.y):
+                            # Diagonal
+                            if vd.x < 0:
+                                keys_active[K.P1_LEFT] = True
+                                # print("..<", end="")
+                            elif vd.x > 0:
+                                keys_active[K.P1_RIGHT] = True
+                                # print("..>", end="")
+                            if vd.y < 0:
+                                keys_active[K.P1_UP] = True
+                                # print("..^", end="")
+                            elif vd.y > 0:
+                                keys_active[K.P1_DOWN] = True
+                                # print("..v", end="")
+                    # elif event.type == pygame.FINGERUP:
+                    #     unset_keys.append(K.P1_RIGHT)
+                    #     unset_keys.append(K.P1_LEFT)
+                    #     unset_keys.append(K.P1_UP)
+                    #     unset_keys.append(K.P1_DOWN)
+                else:
+                    if event.type == pygame.FINGERDOWN:
+                        keys_active[key] = True
+                        # print(f"..{key.name}", end="")
+                    if event.type == pygame.FINGERMOTION:
+                        keys_active[key] = True
+                        # print(f"..{key.name}", end="")
+        # print()
+        for k, val in keys_active.items():
+            if val:
+                set_keys.append(k)
+                # self._state.setdefault(k, {})["active"] = True
+                if k in self._state:
+                    self._state[k]["active"] = True
+                if k in [K.P1_LEFT, K.P1_RIGHT, K.P1_DOWN]:
+                    self._state[K.P1_UP]["active"] = True
+            else:
+                unset_keys.append(k)
+                if k in self._state:
+                    self._state[k]["active"] = False
+        return set_keys, unset_keys
+
+    def get_touch_state(self):
+        state = {}
+        for key, conf in self._state.items():
+            nkey = K(key.value - 12)
+            state[nkey] = conf
+
+        return state

mima/{collision.py → core/collision.py}

@@ -1,19 +1,20 @@
 from __future__ import annotations
 
 import math
+from itertools import product
 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
 
@@ -248,34 +249,50 @@ def add_to_collision_chunk(
     #         collision_chunks[chidx].insert(0, obj)
     #     else:
     #         collision_chunks[chidx].append(obj)
-
-    chid = _test_chunk_position(
-        collision_chunks, obj, obj.px, obj.py, chunk_size, chunks_per_row
-    )
-    chid_right = _test_chunk_position(
-        collision_chunks, obj, obj.px + 1, obj.py, chunk_size, chunks_per_row
-    )
-
-    chid_bottom = _test_chunk_position(
-        collision_chunks, obj, obj.px, obj.py + 1, chunk_size, chunks_per_row
-    )
-
-    chunk_ids.append(chid)
-    if chid != chid_right:
-        chunk_ids.append(chid_right)
-    if chid != chid_bottom:
-        chunk_ids.append(chid_bottom)
-    if chid != chid_right and chid != chid_bottom:
+    centerx = obj.px + (obj.hitbox_px + obj.hitbox_width) / 2
+    centery = obj.py + (obj.hitbox_py + obj.hitbox_height) / 2
+    # chid = _test_chunk_position(
+    #     collision_chunks, obj, centerx, centery, chunk_size, chunks_per_row
+    # )
+    offsets = [[0, 0]] + [
+        list(p) for p in product([-1, 0, 1], repeat=2) if p != (0, 0)
+    ]
+    for x, y in offsets:
         chunk_ids.append(
             _test_chunk_position(
                 collision_chunks,
                 obj,
-                obj.px + 1,
-                obj.py + 1,
+                centerx + x,
+                centery + y,
                 chunk_size,
                 chunks_per_row,
             )
         )
+    chunk_ids = list(dict.fromkeys(chunk_ids))
+    # chid_right = _test_chunk_position(
+    #     collision_chunks, obj, obj.px + 1, obj.py, chunk_size, chunks_per_row
+    # )
+
+    # chid_bottom = _test_chunk_position(
+    #     collision_chunks, obj, obj.px, obj.py + 1, chunk_size, chunks_per_row
+    # )
+
+    # chunk_ids.append(chid)
+    # if chid != chid_right:
+    #     chunk_ids.append(chid_right)
+    # if chid != chid_bottom:
+    #     chunk_ids.append(chid_bottom)
+    # if chid != chid_right and chid != chid_bottom:
+    #     chunk_ids.append(
+    #         _test_chunk_position(
+    #             collision_chunks,
+    #             obj,
+    #             obj.px + 1,
+    #             obj.py + 1,
+    #             chunk_size,
+    #             chunks_per_row,
+    #         )
+    #     )
 
     for chid in obj.chunks:
         if (

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.py → core/engine.py}

@@ -4,32 +4,30 @@ 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 .view.game_mode import GameMode
-from .view.mima_view import MimaView
-
-# from .view.scene import Scene
+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.mima_view import MimaView
+from .database import Database
 
 if TYPE_CHECKING:
     from .states.game_state import GameState
@@ -52,7 +50,7 @@ class MimaEngine(ABC):
         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
@@ -60,6 +58,9 @@ class MimaEngine(ABC):
         self.elapsed_time: float = 0.00022
         self._app_time: float = 0.0
 
+        self.enable_touch_controls: bool = False
+        self.show_touch_controls: bool = False
+
         self.mode: Mode = Mode.LOADING
         self.gate_color: GateColor = GateColor.RED
         self.n_gate_colors = 2
@@ -67,9 +68,6 @@ class MimaEngine(ABC):
         self.memory: Memory = Memory()
         self.all_games: Dict[str, GameState] = {}
         self.current_game: str = ""
-        # self.player: Creature
-        # self.quests: List[Quest] = []
-        # self._items: Dict[str, Item] = {}
         self.cameras: List[str] = []
 
     def construct(
@@ -86,6 +84,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 +99,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(),
@@ -108,6 +108,9 @@ class MimaEngine(ABC):
         self.backend.construct(
             width, height, pixel_size, fullscreen, target_fps, resizable
         )
+        self.backend.user_input.enable_touch_controls = (
+            self.enable_touch_controls
+        )
 
         return True
 
@@ -200,9 +203,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:

mima/{mode_engine.py → 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__)
@@ -33,6 +33,7 @@ class MimaModeEngine(MimaEngine):
 
         self.draw_chunks: bool = False
         self.draw_chunk_info: bool = False
+        self.draw_dyn_ids: bool = False
         self.disable_filter: bool = False
         self._timer = 1.0
 

mima/{scene_engine.py → 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/maps/template.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING, Dict, Optional, Union
 
 from ..util.functions import strtobool
 from ..util.property import Property
@@ -39,3 +39,33 @@ class Template:
             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/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",