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

mima/objects/world/movable.py

@@ -1,6 +1,7 @@
 import math
 from typing import List, Optional
 
+from ...maps.tilemap import Tilemap
 from ...types.alignment import Alignment
 from ...types.damage import Damage
 from ...types.direction import Direction
@@ -19,34 +20,29 @@ class Movable(Dynamic):
         self,
         px: float,
         py: float,
-        tileset_name: str,
-        image_name: str,
+        name="Movable",
+        *,
         sprite_name: str,
-        facing_direction: Direction,
-        graphic_state: GraphicState,
-        mrange: float,
-        liftable: bool,
-        destroyable: bool,
-        movable: bool,
-        intangible: bool,
-        force_collision_check: bool,
-        tilemap=None,
+        tilemap: Optional[Tilemap] = None,
         dyn_id=-1,
-        name="Movable",
+        mrange: float = 0.0,
+        liftable: bool = False,
+        destroyable: bool = False,
+        movable: bool = False,
+        intangible: bool = False,
+        force_collision_check: 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,
+            tilemap=tilemap,
+            sprite_name=sprite_name,
+            dyn_id=dyn_id,
         )
+
         self.type = ObjectType.MOVABLE
         self.alignment = Alignment.NEUTRAL
-        self.facing_direction = facing_direction
-        self.graphic_state = graphic_state
         self.solid_vs_map = True
 
         self.range = mrange
@@ -67,12 +63,22 @@ class Movable(Dynamic):
         self.actor: Optional[Dynamic] = None
         self.vx_mask = 0
         self.vy_mask = 0
+        self._vx_throw = 0
+        self._vy_throw = 0
+        self._speed_throw = 4.0
         self.move_direction: str = ""
         self.moves_on_collision = self.movable or self.destroyable
         # self.onscreen_collision_skippable = (
         #     not self.movable and not force_collision_check
         # )
 
+        self._impact_offsets = [
+            [0.5, 0.5],
+            [-0.5, 0.5],
+            [-0.5, -0.5],
+            [0.5, -0.5],
+        ]
+
     def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
         if self.intangible:
             self.solid_vs_dyn = False
@@ -199,7 +205,11 @@ class Movable(Dynamic):
     def _throw(self):
         if self.pz < 0.5:
             self.solid_vs_dyn = True
+            self.speed = 1.0
         if self.pz > 0:
+            self.vx = self._vx_throw
+            self.vy = self._vy_throw
+            self.speed = self._speed_throw
             return
 
         self._create_impact()
@@ -265,13 +275,13 @@ class Movable(Dynamic):
             # Throw away
             self.vx = self.vy = 0
             if self.actor.facing_direction == Direction.SOUTH:
-                self.vy = 4
+                self.vy = self._vy_throw = 1
             if self.actor.facing_direction == Direction.WEST:
-                self.vx = -4
+                self.vx = self._vx_throw = -1
             if self.actor.facing_direction == Direction.NORTH:
-                self.vy = -4
+                self.vy = self._vy_throw = -1
             if self.actor.facing_direction == Direction.EAST:
-                self.vx = 4
+                self.vx = self._vx_throw = 1
 
             self.vz = 6.0
             self.pz = self.actor.pz + 0.9
@@ -295,85 +305,92 @@ class Movable(Dynamic):
             self.vx = self.vy = 0.0
 
     def _create_impact(self):
-        impact: List[Projectile] = []
-        impact.append(
-            Projectile(
-                self.px + 0.5,
-                self.py + 0.5,
-                0,
-                0,
-                0.2,
-                self.alignment,
-                self.tilemap,
-            )
-        )
-        impact.append(
-            Projectile(
-                self.px - 0.5,
-                self.py + 0.5,
-                0,
-                0,
-                0.2,
-                self.alignment,
-                self.tilemap,
-            )
-        )
-        impact.append(
-            Projectile(
-                self.px - 0.5,
-                self.py - 0.5,
-                0,
-                0,
-                0.2,
-                self.alignment,
-                self.tilemap,
-            )
-        )
-        impact.append(
-            Projectile(
-                self.px + 0.5,
-                self.py - 0.5,
-                0,
-                0,
-                0.2,
-                self.alignment,
-                self.tilemap,
+        # impact: List[Projectile] = []
+        # impact.append(
+        #     Projectile(
+        #         self.px + 0.5,
+        #         self.py + 0.5,
+        #         0,
+        #         0,
+        #         0.2,
+        #         self.alignment,
+        #         self.tilemap,
+        #     )
+        # )
+        for idx, offsets in enumerate(self._impact_offsets):
+            p = Projectile(
+                self.px + offsets[0],
+                self.py + offsets[1],
+                f"Movable Impact {idx}",
+                sprite_name="small_explosion",
+                tilemap=self.tilemap,
+                alignment=self.alignment,
+                duration=0.2,
             )
-        )
+            p.solid_vs_dyn = False
+            p.solid_vs_map = False
+            p.damage = 5
+            # impact.append(p)
+            self.engine.get_view().add_projectile(p, self.tilemap.name)
+
+        # impact.append(
+        #     Projectile(
+        #         self.px - 0.5,
+        #         self.py + 0.5,
+        #         0,
+        #         0,
+        #         0.2,
+        #         self.alignment,
+        #         self.tilemap,
+        #     )
+        # )
+        # impact.append(
+        #     Projectile(
+        #         self.px - 0.5,
+        #         self.py - 0.5,
+        #         0,
+        #         0,
+        #         0.2,
+        #         self.alignment,
+        #         self.tilemap,
+        #     )
+        # )
+        # impact.append(
+        #     Projectile(
+        #         self.px + 0.5,
+        #         self.py - 0.5,
+        #         0,
+        #         0,
+        #         0.2,
+        #         self.alignment,
+        #         self.tilemap,
+        #     )
+        # )
 
-        for pro in impact:
-            pro.sprite.name = "explosion"
-            pro.solid_vs_dyn = False
-            pro.solid_vs_map = False
-            pro.damage = 5
-            self.engine.view.add_projectile(pro, self.tilemap.name)
+        # for pro in impact:
+        #     pro.sprite.name = "explosion"
+        #     pro.solid_vs_dyn = False
+        #     pro.solid_vs_map = False
+        #     pro.damage = 5
 
     @staticmethod
     def load_from_tiled_object(obj, px, py, width, height, tilemap):
         movable = Movable(
             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"),
-            graphic_state=GraphicState[
-                obj.get_string("graphic_state", "standing").upper()
-            ],
-            facing_direction=Direction[
-                obj.get_string("facing_direction", "south").upper()
-            ],
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
             mrange=obj.get_float("range"),
             liftable=obj.get_bool("liftable"),
             destroyable=obj.get_bool("destroyable"),
             movable=obj.get_bool("movable"),
             intangible=obj.get_bool("intangible"),
             force_collision_check=obj.get_bool("force_collision_check"),
-            tilemap=tilemap,
-            dyn_id=obj.object_id,
-            name=obj.name,
         )
-        movable.sprite.width = int(width * Movable.engine.rtc.tile_width)
-        movable.sprite.height = int(height * Movable.engine.rtc.tile_height)
+        # movable.sprite.width = int(width * Movable.engine.rtc.tile_width)
+        # movable.sprite.height = int(height * Movable.engine.rtc.tile_height)
         for dt in Damage:
             movable.attributes.defense[dt] = obj.get_int(
                 f"defense_{dt.name.lower()}"

mima/objects/world/oneway.py

@@ -1,3 +1,6 @@
+from typing import List, Optional, Union
+
+from ...maps.tilemap import Tilemap
 from ...scripts.commands.oneway_move import CommandOnewayMove
 from ...types.direction import Direction
 from ...types.graphic_state import GraphicState
@@ -13,30 +16,25 @@ class Oneway(Dynamic):
         self,
         px: float,
         py: float,
-        tileset_name: str,
-        image_name: str,
-        sprite_name: str,
-        facing_direction: Direction,
-        graphic_state: GraphicState,
-        jump_vx: float,
-        jump_vy: float,
-        width: float,
-        height: float,
-        tilemap,
-        dyn_id=-1,
         name="Oneway",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id=-1,
+        jump_vx: float = 0.0,
+        jump_vy: float = 0.0,
+        width: float = 0.0,
+        height: float = 0.0,
     ):
-        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,
+            tilemap=tilemap,
+            sprite_name=sprite_name,
+            dyn_id=dyn_id,
         )
         self.type = ObjectType.ONEWAY
-        self.graphic_state = graphic_state
-        self.facing_direction = facing_direction
         self.sprite.width = int(width * self.engine.rtc.tile_width)
         self.sprite.height = int(height * self.engine.rtc.tile_height)
 
@@ -151,23 +149,21 @@ class Oneway(Dynamic):
     @staticmethod
     def load_from_tiled_object(obj, px, py, width, height, tilemap):
         oneway = Oneway(
-            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", "standing").upper()
-            ],
-            facing_direction=Direction[
-                obj.get_string("facing_direction", "south").upper()
-            ],
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
             jump_vx=obj.get_float("jump_vx"),
             jump_vy=obj.get_float("jump_vy"),
             width=width,
             height=height,
-            tilemap=tilemap,
-            dyn_id=obj.object_id,
-            name=obj.name,
+        )
+        oneway.graphic_state = (
+            GraphicState[obj.get_string("graphic_state", "standing").upper()],
+        )
+        oneway.facing_direction = (
+            Direction[obj.get_string("facing_direction", "south").upper()],
         )
         return [oneway]

mima/objects/world/pickup.py

@@ -1,27 +1,60 @@
+from typing import Optional
+
+from ...maps.tilemap import Tilemap
 from ...objects.dynamic import Dynamic
+from ...types.direction import Direction
+from ...types.graphic_state import GraphicState
 from ...types.nature import Nature
 from ...types.object import ObjectType
 from ...types.terrain import Terrain
+from ...usables.item import Item
 from ...util.colors import BLACK
+from ..animated_sprite import AnimatedSprite
 from ..effects.walking_on_grass import WalkingOnGrass
 from ..effects.walking_on_water import WalkingOnWater
 
 
 class Pickup(Dynamic):
     def __init__(
-        self, px: float, py: float, item_name: str, tilemap, dyn_id=0
+        self,
+        px: float,
+        py: float,
+        item: Item,
+        *,
+        tilemap: Optional[Tilemap] = None,
+        dyn_id=0,
     ):
-        super().__init__(px, py, "Pickup", tilemap, dyn_id)
+        super().__init__(
+            px,
+            py,
+            f"Pickup({item.name})",
+            sprite_name=item.sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+        )
         self.type: ObjectType = ObjectType.PICKUP
-        self.item = self.engine.get_item(item_name)
+        self.item = item
+        # if not sprite_name:
+        #     sprite_name = self.item.sprite_name
+
         self.collected = False
         self.solid_vs_dyn = False
+        # self.sprite = AnimatedSprite(
+        #     self.item.tileset_name,
+        #     self.item.image_name,
+        #     self.item.sprite_name,
+        #     graphic_state,
+        #     facing_direction,
+        # )
 
     def update(self, elapsed_time: float, target=None):
         if self.collected:
             self.kill()
         else:
             self._handle_terrain(elapsed_time)
+            self.sprite.update(
+                elapsed_time, self.facing_direction, self.graphic_state
+            )
 
     def on_interaction(self, target: Dynamic, nature: Nature):
         if self.collected:
@@ -38,29 +71,37 @@ class Pickup(Dynamic):
 
         return False
 
-    def draw_self(self, ox: float, oy: float, camera_name: str = "display"):
+    def draw_self(
+        self,
+        ox: float,
+        oy: float,
+        camera_name: str = "display",
+        draw_to_ui: bool = False,
+    ):
         if self.collected:
             return
 
         if self.pz != 0:
             self.engine.backend.fill_circle(
-                (self.px - ox + 0.5) * self.item.sprite_width,
-                (self.py - oy + 0.7) * self.item.sprite_height,
-                0.2875 * self.item.sprite_width,
+                (self.px - ox + 0.5) * self.sprite.width,
+                (self.py - oy + 0.7) * self.sprite.height,
+                0.2875 * self.sprite.width,
                 BLACK,
                 camera_name,
             )
-
-        self.engine.backend.draw_partial_sprite(
-            (self.px - ox) * self.item.sprite_width,
-            (self.py - oy - self.pz) * self.item.sprite_height,
-            self.item.sprite_name,
-            self.item.sprite_ox * self.item.sprite_width,
-            self.item.sprite_oy * self.item.sprite_height,
-            self.item.sprite_width,
-            self.item.sprite_height,
-            camera_name,
+        self.sprite.draw_self(
+            self.px - ox, self.py - oy, camera_name, draw_to_ui=draw_to_ui
         )
+        # self.engine.backend.draw_partial_sprite(
+        #     (self.px - ox) * self.item.sprite_width,
+        #     (self.py - oy - self.pz) * self.item.sprite_height,
+        #     self.item.sprite_name,
+        #     self.item.sprite_ox * self.item.sprite_width,
+        #     self.item.sprite_oy * self.item.sprite_height,
+        #     self.item.sprite_width,
+        #     self.item.sprite_height,
+        #     camera_name,
+        # )
 
     def _handle_terrain(self, elapsed_time: float):
         """Method is duplicated."""
@@ -91,3 +132,20 @@ class Pickup(Dynamic):
                 self.engine.scene.add_effect(eff)
         # else:
         #     self.attributes.speed_mod = 1.0
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
+        item = Pickup.engine.get_item(obj.get_string("usable_id"))
+
+        pickup = Pickup(
+            px,
+            py,
+            item,
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
+        )
+
+        # pickup.sprite.width = int(width * Pickup.engine.rtc.tile_width)
+        # pickup.sprite.height = int(height * Pickup.engine.rtc.tile_height)
+
+        return [pickup]

mima/objects/world/switch.py

@@ -1,5 +1,6 @@
 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
@@ -14,34 +15,33 @@ class Switch(Dynamic):
         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=0,
         name="Switch",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id=0,
+        graphic_state: GraphicState = GraphicState.OPEN,
+        initial_signal=True,
     ):
-        assert graphic_state in [GraphicState.OPEN, GraphicState.CLOSED], (
-            f"graphic_state of Switch {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,
+        if graphic_state not in [GraphicState.OPEN, GraphicState.CLOSED]:
+            msg = (
+                f"graphic_state of Switch {name}{dyn_id} must be either "
+                f" 'open' or 'closed', but it is {graphic_state.name}"
+            )
+            raise ValueError(msg)
+
+        super().__init__(
+            px,
+            py,
+            name,
+            tilemap=tilemap,
+            sprite_name=sprite_name,
+            dyn_id=dyn_id,
         )
 
         self.type = ObjectType.SWITCH
         self.alignment = Alignment.NEUTRAL
         self.graphic_state = graphic_state
-        self.facing_direction = facing_direction
         self.signal = self.graphic_state == GraphicState.CLOSED
         self.listener_ids: List[int] = []
         self.listeners: List[Dynamic] = []
@@ -138,23 +138,18 @@ class Switch(Dynamic):
         switch = Switch(
             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,
         )
 
-        switch.sprite.width = int(width * Switch.engine.rtc.tile_width)
-        switch.sprite.height = int(height * Switch.engine.rtc.tile_height)
+        # switch.sprite.width = int(width * Switch.engine.rtc.tile_width)
+        # switch.sprite.height = int(height * Switch.engine.rtc.tile_height)
 
         ctr = 1
         while True:

mima/objects/world/teleport.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import logging
 from typing import List, Optional
 
+from ...maps.tilemap import Tilemap
 from ...scripts.commands.change_map import CommandChangeMap
 from ...scripts.commands.move_map import CommandMoveMap
 from ...scripts.commands.parallel import CommandParallel
@@ -25,9 +26,11 @@ class Teleport(Dynamic):
         self,
         px: float,
         py: float,
-        tileset_name: str,
-        image_name: str,
-        sprite_name: str,
+        name="Teleport",
+        *,
+        sprite_name: str = "str",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
         facing_direction: Direction,
         graphic_state: GraphicState,
         dst_map_name: str,
@@ -38,20 +41,24 @@ class Teleport(Dynamic):
         relative: bool = False,
         sliding: bool = False,
         vertical: bool = False,
-        tilemap=None,
-        dyn_id: int = -1,
-        name="Teleport",
     ):
-        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.sprite = AnimatedSprite(
+        #     tileset_name,
+        #     image_name,
+        #     sprite_name,
+        #     graphic_state,
+        #     facing_direction,
+        # )
+
         self.type = ObjectType.TELEPORT
         self.graphic_state = graphic_state
         self.facing_direction = facing_direction
@@ -176,8 +183,6 @@ class Teleport(Dynamic):
         obj, px, py, width, height, tilemap
     ) -> List[Teleport]:
         sprite_name = obj.get_string("sprite_name")
-        tileset_name = obj.get_string("tileset_name")
-        image_name = obj.get_string("tileset_name")
         graphic_state = GraphicState[
             obj.get_string("graphic_state", "closed").upper()
         ]
@@ -214,8 +219,6 @@ class Teleport(Dynamic):
                     Teleport(
                         px=from_px,
                         py=from_py,
-                        tileset_name=tileset_name,
-                        image_name=image_name,
                         sprite_name=sprite_name,
                         graphic_state=graphic_state,
                         facing_direction=facing_direction,
@@ -253,8 +256,6 @@ class Teleport(Dynamic):
                     Teleport(
                         px=from_px,
                         py=from_py,
-                        tileset_name=tileset_name,
-                        image_name=image_name,
                         sprite_name=sprite_name,
                         graphic_state=graphic_state,
                         facing_direction=facing_direction,
@@ -285,8 +286,6 @@ class Teleport(Dynamic):
                 Teleport(
                     px=px,
                     py=py,
-                    tileset_name=tileset_name,
-                    image_name=image_name,
                     sprite_name=sprite_name,
                     graphic_state=graphic_state,
                     facing_direction=facing_direction,

mima/scripts/commands/close_dialog.py

@@ -3,6 +3,7 @@ from ..command import Command
 
 class CommandCloseDialog(Command):
     def start(self):
-        self.engine.dialog_active = False
+        for player in self.players:
+            self.engine.trigger_dialog(False, player)
         self.engine.exit_dialog_active = False
         self.completed = True