mima-engine 0.2.2__py3-none-any.whl → 0.2.4__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,26 @@ 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.layer = 0
         self.sprite.width = int(width * self.engine.rtc.tile_width)
         self.sprite.height = int(height * self.engine.rtc.tile_height)
 
@@ -48,24 +47,26 @@ class Oneway(Dynamic):
         self.height: float = height
         self.jump_vx: float = 0.0
         self.jump_vy: float = 0.0
+        self.jump_direction = Direction.from_velocity(jump_vx, jump_vy)
         self.activation_delay: float = ONEWAY_ACTIVATION_DELAY
         self.triggered: bool = False
+        self.is_active: bool = False
         self.cooldown: float = 0.0
         self.target = None
 
         if jump_vx < 0:
             self.jump_vx = jump_vx - 1
-            self.hitbox_px += 0.1
+            # self.hitbox_px += 0.1
         elif jump_vx > 0:
             self.jump_vx = jump_vx + 1
-            self.hitbox_px -= 0.1
+            # self.hitbox_px -= 0.1
 
         if jump_vy < 0:
             self.jump_vy = jump_vy - 1
-            self.hitbox_py += 0.1
+            # self.hitbox_py += 0.1
         elif jump_vy > 0:
             self.jump_vy = jump_vy + 1
-            self.hitbox_py -= 0.1
+            # self.hitbox_py -= 0.1
 
     def update(self, elapsed_time, target=None):
         self.sprite.update(
@@ -92,9 +93,15 @@ class Oneway(Dynamic):
         # Activation countdown reached 0 and the jump is initiated.
         if self.timer <= 0.0 and self.target is not None:
             self.engine.script.add_command(
-                CommandOnewayMove(self.target, self.jump_vx, self.jump_vy)
+                CommandOnewayMove(
+                    self.target,
+                    self.jump_vx,
+                    self.jump_vy,
+                    target.get_player(),
+                )
             )
             self.cooldown = 2.0
+            self.is_active
 
         # Reset the triggered flag so it has to be activated again
         # by interaction
@@ -102,11 +109,25 @@ class Oneway(Dynamic):
         self.target = None
 
     def on_interaction(self, target, nature=Nature.WALK):
-        if target.type == ObjectType.PLAYER and nature == Nature.WALK:
+        if (
+            target.type == ObjectType.PLAYER
+            and nature == Nature.WALK
+            and self.cooldown <= 0.0
+        ):
             # No interaction when target is higher than the oneway
             if target.pz > 0:
                 return False
 
+            if self.jump_direction != target.facing_direction:
+                return False
+
+            tcenterx = target.px + (target.hitbox_px + target.hitbox_width) / 2
+            tbottomy = target.py + target.hitbox_py + target.hitbox_height
+            ttopy = target.py + target.hitbox_py
+            tleftx = target.px + target.hitbox_px
+            trightx = tleftx + target.hitbox_width
+
+            # print(tcenterx, tbottomy)
             # We have to check that target is not placed "more" in the
             # target direction than the oneway
             if (
@@ -121,7 +142,7 @@ class Oneway(Dynamic):
                 and target.py <= self.py + self.height - target.hitbox_py
             ):
                 return False
-            if self.jump_vy > 0 and target.py >= self.py:
+            if self.jump_vy > 0 and tbottomy >= self.py:  # FIXME
                 return False
 
             if self.jump_vx == 0:
@@ -135,12 +156,15 @@ class Oneway(Dynamic):
                     return False
                 if target.py + 1.0 <= self.py:
                     return False
-
             self.triggered = True
             self.target = target
             if self.timer <= 0.0:
                 self.timer = self.activation_delay
+                # return False
 
+            # print(
+            #     f"activated {self.timer:.3f}, {self.px, self.py}, {target.px, target.py}, {target.sprite.width, target.sprite.height}"
+            # )
             return True
 
         return False
@@ -151,23 +175,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,61 @@
+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.moves_on_collision = True
+        # 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 +72,42 @@ 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:
+
+            # print("Draw item circle")
             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,
+        self.sprite.draw_self(
+            self.px - ox,
+            self.py - oy - self.pz,
             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."""
@@ -88,6 +135,23 @@ class Pickup(Dynamic):
                 else:
                     eff = WalkingOnWater(self)
                 self.effects.append(eff)
-                self.engine.scene.add_effect(eff)
+                self.engine.get_view().add_effect(eff, self.tilemap.name)
         # 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]