mima-engine 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

mima/objects/world/color_switch.py

@@ -19,29 +19,24 @@ class ColorSwitch(Switch):
         self,
         px: float,
         py: float,
-        tileset_name: str,
-        image_name: str,
-        sprite_name: str,
-        facing_direction: Direction,
-        graphic_state: GraphicState,
-        color: GateColor,
-        initial_signal=True,
-        tilemap: Tilemap = None,
-        dyn_id=-1,
         name="ColorSwitch",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id=-1,
+        graphic_state: GraphicState = GraphicState.OPEN,
+        initial_signal=False,
+        color: GateColor = GateColor.RED,
     ):
         super().__init__(
             px,
             py,
-            tileset_name,
-            image_name,
-            sprite_name,
-            facing_direction,
-            graphic_state,
-            initial_signal,
-            tilemap,
-            dyn_id,
             name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+            graphic_state=graphic_state,
+            initial_signal=initial_signal,
         )
         self.type = ObjectType.COLOR_SWITCH
 
@@ -52,7 +47,7 @@ class ColorSwitch(Switch):
             else GraphicState.OPEN
         )
         # self.signal = self.graphic_state == GraphicState.CLOSED
-        self.send_initial_signal = False
+        # self.send_initial_signal = False
 
     def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
         self.graphic_state = (
@@ -89,23 +84,18 @@ class ColorSwitch(Switch):
         switch = ColorSwitch(
             px=px,
             py=py,
-            tileset_name=obj.get_string("tileset_name"),
-            image_name=obj.get_string("tileset_name"),
+            name=obj.name,
             sprite_name=obj.get_string("sprite_name"),
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
             graphic_state=GraphicState[
                 obj.get_string("graphic_state", "closed").upper()
             ],
-            facing_direction=Direction[
-                obj.get_string("facing_direction", "south").upper()
-            ],
             color=GateColor[obj.get_string("color", "red").upper()],
             initial_signal=False,
-            tilemap=tilemap,
-            dyn_id=obj.object_id,
-            name=obj.name,
         )
 
-        switch.sprite.width = int(width * ColorSwitch.engine.rtc.tile_width)
-        switch.sprite.height = int(height * ColorSwitch.engine.rtc.tile_height)
+        # switch.sprite.width = int(width * ColorSwitch.engine.rtc.tile_width)
+        # switch.sprite.height = int(height * ColorSwitch.engine.rtc.tile_height)
 
         return [switch]

mima/objects/world/container.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import logging
 from typing import List, Optional
 
+from ...maps.tilemap import Tilemap
 from ...scripts.commands.give_item import CommandGiveItem
 from ...scripts.commands.give_resource import CommandGiveResource
 from ...scripts.commands.parallel import CommandParallel
@@ -23,39 +24,38 @@ class Container(Dynamic):
         self,
         px: float,
         py: float,
-        tileset_name: str,
-        image_name: str,
-        sprite_name: str,
-        graphic_state: GraphicState,
-        facing_direction: Direction,
-        item_name: str,
-        tilemap=None,
-        dyn_id: int = -1,
         name: str = "Container",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
+        graphic_state: GraphicState = GraphicState.CLOSED,
+        item_name: str = "",
     ):
-        assert graphic_state in [
+        if graphic_state not in [
             GraphicState.OPEN,
             GraphicState.CLOSED,
-        ], (
-            f"graphic_state of Container {name}{dyn_id} must be either 'open'"
-            f" or 'closed', but it {graphic_state}"
-        )
-        super().__init__(px, py, name, tilemap, dyn_id)
-
-        self.sprite = AnimatedSprite(
-            tileset_name,
-            image_name,
-            sprite_name,
-            graphic_state,
-            facing_direction,
+        ]:
+            msg = (
+                f"graphic_state of Container {name}{dyn_id} must be either "
+                f"'open' or 'closed', but it is {graphic_state}"
+            )
+            raise ValueError(msg)
+        super().__init__(
+            px,
+            py,
+            name,
+            tilemap=tilemap,
+            sprite_name=sprite_name,
+            dyn_id=dyn_id,
         )
 
         self.type = ObjectType.CONTAINER
         self.graphic_state = graphic_state
-        self.facing_direction = facing_direction
         self.closed: bool = self.graphic_state != GraphicState.OPEN
 
         self.item_name: str = item_name
+        self.item = self.engine.get_item(item_name)
         self.solid_vs_dyn: bool = True
         self.solid_vs_map: bool = True
         self.visible: bool = True
@@ -102,19 +102,19 @@ class Container(Dynamic):
                 if self.is_resource:
                     text = "You received "
                     if self.amount > 1:
-                        text += f"{self.amount} {self.item_name}s!"
+                        text += f"{self.amount} {self.item.name}s!"
                     elif self.amount == 1:
-                        text += f"one {self.item_name}!"
+                        text += f"one {self.item.name}!"
                     else:
                         text += "nothing. The chest was empty!"
 
-                    if self.item_name == "Coin":
+                    if self.item_name == "coin":
                         cgr = CommandGiveResource(target, coins=self.amount)
-                    elif self.item_name == "Bomb Refill":
+                    elif self.item_name == "bomb_refill":
                         cgr = CommandGiveResource(target, bombs=self.amount)
-                    elif self.item_name == "Arrow Refill":
+                    elif self.item_name == "arrow_refill":
                         cgr = CommandGiveResource(target, arrows=self.amount)
-                    elif self.item_name == "Key":
+                    elif self.item_name == "key":
                         cgr = CommandGiveResource(target, keys=self.amount)
                     else:
                         LOG.error(f"Invalid resource type: {self.item_name}")
@@ -160,19 +160,14 @@ class Container(Dynamic):
         container = Container(
             px=px,
             py=py,
-            tileset_name=obj.get_string("tileset_name"),
-            image_name=obj.get_string("tileset_name"),
+            name=obj.name,
             sprite_name=obj.get_string("sprite_name"),
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
             graphic_state=GraphicState[
                 obj.get_string("graphic_state", "closed").upper()
             ],
-            facing_direction=Direction[
-                obj.get_string("facing_direction", "south").upper()
-            ],
             item_name=obj.get_string("item_name"),
-            tilemap=tilemap,
-            dyn_id=obj.object_id,
-            name=obj.name,
         )
         container.is_resource = obj.get_bool("is_resource", False)
         container.amount = obj.get_int("amount", 1)

mima/objects/world/floor_switch.py

@@ -1,3 +1,6 @@
+from typing import Optional
+
+from ...maps.tilemap import Tilemap
 from ...types.direction import Direction
 from ...types.graphic_state import GraphicState
 from ...types.nature import Nature
@@ -11,28 +14,23 @@ class FloorSwitch(Switch):
         self,
         px: float,
         py: float,
-        tileset_name: str,
-        image_name: str,
-        sprite_name: str,
-        facing_direction: Direction,
-        graphic_state: GraphicState,
-        initial_signal=True,
-        tilemap=None,
-        dyn_id=-1,
         name="Floor Switch",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
+        graphic_state: GraphicState = GraphicState.OPEN,
+        initial_signal: bool = True,
     ):
         super().__init__(
             px,
             py,
-            tileset_name,
-            image_name,
-            sprite_name,
-            facing_direction,
-            graphic_state,
-            initial_signal,
-            tilemap,
-            dyn_id,
             name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+            graphic_state=graphic_state,
+            initial_signal=initial_signal,
         )
         self.layer = 0
 
@@ -84,24 +82,20 @@ class FloorSwitch(Switch):
         fswitch = FloorSwitch(
             px=px,
             py=py,
-            tileset_name=obj.get_string("tileset_name"),
-            image_name=obj.get_string("tileset_name"),
+            name=obj.name,
             sprite_name=obj.get_string("sprite_name"),
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
             graphic_state=GraphicState[
                 obj.get_string("graphic_state", "closed").upper()
             ],
-            facing_direction=Direction[
-                obj.get_string("facing_direction", "south").upper()
-            ],
             initial_signal=obj.get_bool("initial_signal", True),
-            tilemap=tilemap,
-            dyn_id=obj.object_id,
-            name=obj.name,
-        )
-        fswitch.sprite.width = int(width * FloorSwitch.engine.rtc.tile_width)
-        fswitch.sprite.height = int(
-            height * FloorSwitch.engine.rtc.tile_height
         )
+        # TODO: Why was this used?
+        # fswitch.sprite.width = int(width * FloorSwitch.engine.rtc.tile_width)
+        # fswitch.sprite.height = int(
+        #     height * FloorSwitch.engine.rtc.tile_height
+        # )
 
         ctr = 1
         while True:

mima/objects/world/gate.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+from typing import Optional
+
+from ...maps.tilemap import Tilemap
 from ...types.damage import Damage
 from ...types.direction import Direction
 from ...types.graphic_state import GraphicState
@@ -15,34 +18,36 @@ class Gate(Dynamic):
         self,
         px: float,
         py: float,
-        tileset_name: str,
-        image_name: str,
-        sprite_name: str,
-        graphic_state: GraphicState,
-        facing_direction: Direction,
-        bombable: bool = False,
-        tilemap=None,
-        dyn_id: int = 0,
         name: str = "Gate",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = 0,
+        graphic_state: GraphicState = GraphicState.STANDING,
+        facing_direction: Direction = Direction.SOUTH,
+        bombable: bool = False,
     ):
-        assert graphic_state in [
+        if graphic_state not in (
             GraphicState.OPEN,
             GraphicState.CLOSED,
             GraphicState.LOCKED,
-        ], (
-            f"graphic_state of Gate {name}{dyn_id} must be either 'open'"
-            f", 'closed', or 'locked', but it {graphic_state}"
-        )
+        ):
+            msg = (
+                f"graphic_state of Gate {name}{dyn_id} must be either 'open'"
+                f", 'closed', or 'locked', but it {graphic_state}"
+            )
 
-        super().__init__(px, py, name, tilemap, dyn_id)
+            raise ValueError(msg)
 
-        self.sprite = AnimatedSprite(
-            tileset_name,
-            image_name,
-            sprite_name,
-            graphic_state,
-            facing_direction,
+        super().__init__(
+            px,
+            py,
+            name,
+            tilemap=tilemap,
+            sprite_name=sprite_name,
+            dyn_id=dyn_id,
         )
+
         self.type = ObjectType.GATE
 
         self.graphic_state = graphic_state
@@ -126,9 +131,10 @@ class Gate(Dynamic):
             Gate(
                 px=px,
                 py=py,
-                tileset_name=obj.get_string("tileset_name"),
-                image_name=obj.get_string("tileset_name"),
+                name=obj.name,
                 sprite_name=obj.get_string("sprite_name"),
+                tilemap=tilemap,
+                dyn_id=obj.object_id,
                 graphic_state=GraphicState[
                     obj.get_string("graphic_state", "closed").upper()
                 ],
@@ -136,9 +142,6 @@ class Gate(Dynamic):
                     obj.get_string("facing_direction", "south").upper()
                 ],
                 bombable=obj.get_bool("bombable"),
-                tilemap=tilemap,
-                dyn_id=obj.object_id,
-                name=obj.name,
             )
         ]
 
@@ -149,11 +152,12 @@ class Gate(Dynamic):
                 py -= 0.1
 
             teleport = Teleport(
-                px=px,
-                py=py,
-                tileset_name="",
-                image_name="",
+                px,
+                py,
+                f"Teleport of {gate[0].name}",
                 sprite_name="",
+                tilemap=tilemap,
+                dyn_id=gate[0].dyn_id + 2000,
                 dst_map_name=obj.get_string("target_map"),
                 dst_px=obj.get_float("target_px"),
                 dst_py=obj.get_float("target_py"),
@@ -164,9 +168,6 @@ class Gate(Dynamic):
                 relative=False,
                 sliding=False,
                 vertical=False,
-                tilemap=tilemap,
-                dyn_id=gate[0].dyn_id + 2000,
-                name=f"Teleport of {gate[0].name}",
             )
 
             teleport.visible = False

mima/objects/world/light_source.py

@@ -1,5 +1,6 @@
 from typing import Optional
 
+from ...maps.tilemap import Tilemap
 from ...types.direction import Direction
 from ...types.graphic_state import GraphicState
 from ...types.nature import Nature
@@ -15,33 +16,32 @@ class LightSource(Dynamic):
         self,
         px: float,
         py: float,
-        tileset_name: str,
-        image_name: str,
-        sprite_name: str,
-        graphic_state: GraphicState,
-        facing_direction: Direction,
-        max_size: int,
-        tilemap=None,
-        dyn_id: int = -1,
         name: str = "LightSource",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
+        graphic_state: GraphicState = GraphicState.ON,
+        max_size: int = 32,
     ):
-        assert graphic_state in [GraphicState.OFF, GraphicState.ON], (
-            f"graphic_state of LightSource {name}{dyn_id} must be either "
-            f"'off' or 'on', but it {graphic_state}"
-        )
-        super().__init__(px, py, name, tilemap, dyn_id)
-
-        self.sprite = AnimatedSprite(
-            tileset_name,
-            image_name,
-            sprite_name,
-            graphic_state,
-            facing_direction,
+        if graphic_state not in [GraphicState.OFF, GraphicState.ON]:
+            msg = (
+                f"graphic_state of LightSource {name}{dyn_id} must be either "
+                f"'off' or 'on', but it is {graphic_state}"
+            )
+            raise ValueError(msg)
+
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
         )
 
         self.type = ObjectType.LIGHT_SOURCE
         self.graphic_state = graphic_state
-        self.facing_direction = facing_direction
         self._max_size = max_size
         self.active = self.graphic_state == GraphicState.ON
         self._light: Optional[Projectile] = None
@@ -105,22 +105,17 @@ class LightSource(Dynamic):
         light = LightSource(
             px=px,
             py=py,
-            tileset_name=obj.get_string("tileset_name"),
-            image_name=obj.get_string("tileset_name"),
+            name=obj.name,
             sprite_name=obj.get_string("sprite_name"),
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
             graphic_state=GraphicState[
-                obj.get_string("graphic_state", "closed").upper()
-            ],
-            facing_direction=Direction[
-                obj.get_string("facing_direction", "south").upper()
+                obj.get_string("graphic_state", "on").upper()
             ],
             max_size=obj.get_int("max_size", 32),
-            tilemap=tilemap,
-            dyn_id=obj.object_id,
-            name=obj.name,
         )
 
-        light.sprite.width = int(width * LightSource.engine.rtc.tile_width)
-        light.sprite.height = int(height * LightSource.engine.rtc.tile_height)
+        # light.sprite.width = int(width * LightSource.engine.rtc.tile_width)
+        # light.sprite.height = int(height * LightSource.engine.rtc.tile_height)
 
         return [light]

mima/objects/world/logic_gate.py

@@ -1,6 +1,7 @@
 from enum import Enum
 from typing import List, Optional, Union
 
+from ...maps.tilemap import Tilemap
 from ...types.alignment import Alignment
 from ...types.direction import Direction
 from ...types.graphic_state import GraphicState
@@ -27,31 +28,26 @@ class LogicGate(Dynamic):
         self,
         px: float,
         py: float,
-        tileset_name: str,
-        image_name: str,
-        sprite_name: str,
-        graphic_state: GraphicState,
-        facing_direction: Direction,
-        mode=LogicFunction.LOGIC_PASS,
-        initial_signal=False,
-        visible=False,
-        tilemap=None,
-        dyn_id=-1,
-        name="Logic Gate",
+        name: str = "Logic Gate",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
+        mode: LogicFunction = LogicFunction.LOGIC_PASS,
+        initial_signal: bool = False,
+        visible: bool = False,
     ):
-        super().__init__(px, py, name, tilemap, dyn_id)
-
-        self.sprite = AnimatedSprite(
-            tileset_name,
-            image_name,
-            sprite_name,
-            graphic_state,
-            facing_direction,
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
         )
+
         self.type = ObjectType.LOGIC_GATE
         self.alignment = Alignment.NEUTRAL
-        self.graphic_state = graphic_state
-        self.facing_direction = facing_direction
         self.visible = visible
 
         self.input_id1: int = -1
@@ -130,28 +126,25 @@ class LogicGate(Dynamic):
     @staticmethod
     def load_from_tiled_object(obj, px, py, width, height, tilemap):
         logic = LogicGate(
-            px=px,
-            py=py,
-            tileset_name=obj.get_string("tileset_name"),
-            image_name=obj.get_string("tileset_name"),
+            px,
+            py,
+            obj.name,
             sprite_name=obj.get_string("sprite_name"),
-            graphic_state=GraphicState[
-                obj.get_string("graphic_state", "closed").upper()
-            ],
-            facing_direction=Direction[
-                obj.get_string("facing_direction", "south").upper()
-            ],
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
             mode=LogicFunction[obj.get_string("mode", "logic_pass").upper()],
             initial_signal=obj.get_bool("initial_signal", False),
             visible=obj.get_bool("visible", True),
-            tilemap=tilemap,
-            dyn_id=obj.object_id,
-            name=obj.name,
         )
-
+        logic.facing_direction = Direction[
+            obj.get_string("facing_direction", "south").upper()
+        ]
+        logic.graphic_state = GraphicState[
+            obj.get_string("graphic_state", "closed").upper()
+        ]
         # logic.send_initial_signal =
-        logic.sprite.width = int(width * LogicGate.engine.rtc.tile_width)
-        logic.sprite.height = int(height * LogicGate.engine.rtc.tile_height)
+        # logic.sprite.width = int(width * LogicGate.engine.rtc.tile_width)
+        # logic.sprite.height = int(height * LogicGate.engine.rtc.tile_height)
 
         ctr = 1
         while True: