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

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,42 +15,46 @@ 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] = []
         self.send_initial_signal = initial_signal
+        self.cooldown = 0.0
+        self.cooldown_reset = 0.8
 
         # self._gs_map = {False: GraphicState.OPEN, True: GraphicState.CLOSED}
 
     def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        if self.cooldown > 0.0:
+            self.cooldown -= elapsed_time
+
         if self.send_initial_signal:
             self.send_signal(self.signal)
             self.send_initial_signal = False
@@ -71,25 +76,36 @@ class Switch(Dynamic):
     def on_interaction(self, target: Dynamic, nature: Nature):
         # if target.is_player().value > 0:
         #     print(f"{target.is_player()} talked to me({self.name})")
+        if self.cooldown > 0.0:
+            return False
+
         if (
             nature == Nature.TALK
             and target.type == ObjectType.PLAYER
             and self.visible
         ):
             self.state_changed = True
-            self.engine.audio.play_sound("switch")
+            self.engine.audio.play_sound("switch", 0.2)
+            self.cooldown = self.cooldown_reset
+            print("Player talked")
 
         elif nature == Nature.WALK and target.type == ObjectType.PROJECTILE:
             if self.signal:
                 # Projectiles from the right will activate the switch
                 if target.px > self.px and target.vx < 0:
                     self.state_changed = True
+                    if "body" not in target.name:
+                        self.engine.audio.play_sound("switch", 0.2)
+                        self.cooldown = self.cooldown_reset
             else:
                 # Projectiles from the left will (de)activate the switch
-                if target.px <= self.px and target.vx > 0:
+                if (
+                    target.px <= self.px and target.vx > 0
+                ):  # Sword does not activate because vx=0
                     self.state_changed = True
-            if "body" not in target.name:
-                self.engine.audio.play_sound("switch")
+                    if "body" not in target.name:
+                        self.engine.audio.play_sound("switch", 0.2)
+                        self.cooldown = self.cooldown_reset
 
         elif nature == Nature.SIGNAL:
             self.visible = False
@@ -138,23 +154,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/oneway_move.py

@@ -8,11 +8,12 @@ from ...util.constants import ONEWAY_SPEED_BOOST
 
 if TYPE_CHECKING:
     from ...objects.dynamic import Dynamic
+    from ...types.player import Player
 
 
 class CommandOnewayMove(Command):
-    def __init__(self, obj: Dynamic, vx: float, vy: float):
-        super().__init__()
+    def __init__(self, obj: Dynamic, vx: float, vy: float, player: Player):
+        super().__init__([player])
 
         self.obj: Dynamic = obj
         self.vx: float = vx
@@ -27,7 +28,7 @@ class CommandOnewayMove(Command):
         self.obj.solid_vs_map = False
         self.obj.solid_vs_dyn = False
         self.obj.vx = self.obj.vy = 0.0
-        self.obj.vz = 10.0
+        self.obj.vz = 7.5
 
         self.start_px = self.obj.px
         self.start_py = self.obj.py

mima/scripts/commands/present_item.py

@@ -25,18 +25,18 @@ class CommandPresentItem(Command):
         self._item_sprite = Projectile(
             self._dynamic.px,
             self._dynamic.py - 1,
-            0,
-            0,
-            3600,
-            self._dynamic.alignment,
-            self._dynamic.tilemap,
+            f"Present {item.name}",
+            sprite_name=item.sprite_name,
+            tilemap=self._dynamic.tilemap,
+            duration=3600,
+            alignment=self._dynamic.alignment,
         )
         self._item_sprite.layer = 2
-        self._item_sprite.sprite.name = item.sprite_name
-        self._item_sprite.sprite.ox = item.sprite_ox
-        self._item_sprite.sprite.oy = item.sprite_oy
-        self._item_sprite.sprite.width = item.sprite_width
-        self._item_sprite.sprite.height = item.sprite_height
+        # self._item_sprite.sprite.name = item.sprite_name
+        # self._item_sprite.sprite.ox = item.sprite_ox
+        # self._item_sprite.sprite.oy = item.sprite_oy
+        # self._item_sprite.sprite.width = item.sprite_width
+        # self._item_sprite.sprite.height = item.sprite_height
         self._item_sprite.solid_vs_dyn = False
         self._item_sprite.solid_vs_map = False
         self._item_sprite.one_hit = False

mima/types/graphic_state.py

@@ -15,6 +15,7 @@ class GraphicState(Enum):
     LOCKED = 10
     OFF = 11
     ON = 12
+    ICON = 13
 
 
 class Until(Enum):

mima/usables/item.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Dict
 
 from ..util.constants import DEFAULT_SPRITE_HEIGHT, DEFAULT_SPRITE_WIDTH
 
@@ -13,20 +13,39 @@ if TYPE_CHECKING:
 class Item:
     engine: MimaEngine
 
-    def __init__(self, name: str, sprite_name: str, description: str):
-        self.name: str = name
-        self.description: str = description
-        self.sprite_name: str = sprite_name
-        self.sprite_ox: int = 0
-        self.sprite_oy: int = 0
-        self.sprite_width: int = DEFAULT_SPRITE_WIDTH
-        self.sprite_height: int = DEFAULT_SPRITE_HEIGHT
+    def __init__(self):
+        self.name: str = ""
+        self.description: str = ""
+        self.sprite_name: str = ""
+        # self.sprite_ox: int = 0
+        # self.sprite_oy: int = 0
+        # self.sprite_width: int = DEFAULT_SPRITE_WIDTH
+        # self.sprite_height: int = DEFAULT_SPRITE_HEIGHT
         self.key_item: bool = False
         self.equipable: bool = False
         self.price: int = 0
+        self.stackable: bool = False
+        self.stackable_by_merchant: bool = False
+
+    def init(self, data: Dict[str, Any]):
+
+        for key, val in data.items():
+            setattr(self, key, val)
+        # self.usable_id = data["usable_id"]
+        # self.name = data["name"]
+        # self.description = data["description"]
+        # self.price = data.get("attr_price", 0)
+        # self.sprite_name = data.get("sprite_name")
 
     def on_interaction(self, obj: Dynamic):
         return False
 
     def on_use(self, obj: Creature):
         return False
+
+    def __str__(self):
+        txt = f"{type(self).__name__}({self.name})"
+        return txt
+
+    def __repr__(self):
+        return str(self)

mima/usables/weapon.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Tuple
+from typing import TYPE_CHECKING, Any, Dict, Tuple
 
 from ..types.damage import Damage
 from ..types.direction import Direction
@@ -11,20 +11,37 @@ if TYPE_CHECKING:
 
 
 class Weapon(Item):
-    def __init__(self, name: str, sprite: str, description: str):
-        super().__init__(name, sprite, description)
+    def __init__(self):
+        super().__init__()
 
         self.equipable = True
 
         self.damage: int = 0
         self.dtype: Damage = Damage.BODY
-        self.health_cost: int = 0
-        self.magic_cost: int = 0
-        self.stamina_cost: int = 0
+        self.health_cost: float = 0.0
+        self.magic_cost: float = 0.0
+        self.stamina_cost: float = 0.0
         self.arrow_cost: int = 0
         self.bomb_cost: int = 0
-        self.swing_timer: int = 0.2
-        # self.projectiles: List[Projectile] = []
+        self.swing_timer: float = 0.2
+
+    def init(self, data: Dict[str, Any]):
+        for key, val in data.items():
+            setattr(self, key, val)
+        # self.usable_id = data["usable_id"]
+        # self.name = data["display_name"]
+        # self.description = data["description"]
+        # self.sprite_name = data["sprite_name"]
+        # self.price = data["attr_price"]
+        # self.swing_timer = data["attr_swing_timer"]
+        # self.damage = data["attr_damage"]
+        # self.dtype = data["attr_dtype"]
+        # self.health_cost = data["attr_health_cost"]
+        # self.magic_cost = data["attr_magic_cost"]
+        # self.stamina_cost = data["attr_stamina_cost"]
+        # self.bomb_cost = data["attr_bomb_cost"]
+        # self.arrow_cost = data["attr_arrow_cost"]
+        # print()
 
     def _determine_attack_origin(self, obj: Creature) -> Tuple[float, float]:
         vx = 0.0
@@ -46,3 +63,6 @@ class Weapon(Item):
 
     def on_unequip(self, obj: Creature):
         pass
+
+    def on_interaction(self, target: Creature):
+        return True  # Add to inventory

mima/util/constants.py

@@ -10,8 +10,8 @@ UI_HIGHT: int = 1  # TODO: remove
 # Map transition
 MOVE_MAP_DURATION: float = 1.0
 MAP_TRANSITION_DURATION_FACTOR: float = 0.75
-ONEWAY_ACTIVATION_DELAY: float = 0.175
-ONEWAY_SPEED_BOOST: float = 2.0
+ONEWAY_ACTIVATION_DELAY: float = 0.075
+ONEWAY_SPEED_BOOST: float = 2.5
 
 # Gamepad
 AXIS_DEADZONE: float = 0.25
@@ -38,7 +38,7 @@ DEFAULT_GRAPHIC_TIMER_DAMAGED: float = 0.075
 DEFAULT_GRAPHIC_TIMER_DEAD: float = 0.25
 DEFAULT_GRAPHIC_TIMER: float = 0.5
 ATTRIBUTE_TIMER: float = 0.25
-DEFAULT_KNOCK_SPEED: float = 5.0
+DEFAULT_KNOCK_SPEED: float = 6.0
 
 # Gameplay
 ABYSS_DAMAGE: int = 1

mima/util/input_defaults.py

@@ -156,3 +156,15 @@ DEFAULT_TOUCHSCREEN_MAP = {
     K.P1_B: [[0.5, 0.5], [0.75, 1.0]],
     K.P1_A: [[0.75, 0.5], [1.0, 1.0]],
 }
+
+ALT_TOUCHSCREEN_MAP = {
+    K.P1_UP: {"pos": [0.1, 0.2], "size": [0.4, 0.7]},
+    K.P1_A: {"pos": [0.83, 0.84], "size": [0.12, 0.12]},
+    K.P1_B: {"pos": [0.70, 0.84], "size": [0.12, 0.12]},
+    K.P1_X: {"pos": [0.76, 0.69], "size": [0.12, 0.12]},
+    K.P1_Y: {"pos": [0.63, 0.69], "size": [0.12, 0.12]},
+    K.P1_START: {"pos": [0.39, 0.02], "size": [0.1, 0.1]},
+    K.P1_SELECT: {"pos": [0.51, 0.02], "size": [0.1, 0.1]},
+    K.P1_L: {"pos": [0.01, 0.3], "size": [0.05, 0.4]},
+    K.P1_R: {"pos": [0.94, 0.3], "size": [0.05, 0.4]},
+}

mima/util/runtime_config.py

@@ -106,9 +106,7 @@ class RuntimeConfig:
         self._converted: Dict[str, Any] = {}
 
         if not config_path:
-            config_path = os.path.abspath(
-                os.path.join(os.getcwd(), "mima.ini")
-            )
+            config_path = os.path.abspath(os.path.join(os.getcwd(), "mima.ini"))
 
         self._config_path = config_path
         config = configparser.ConfigParser()
@@ -145,6 +143,9 @@ class RuntimeConfig:
         self.small_font_width = SMALL_FONT_WIDTH
         self.small_font_height = SMALL_FONT_HEIGHT
 
+        ## Locale
+        self.locale = "en"
+
     def _read_config(self, config: configparser.ConfigParser):
         mappings = [
             "keyboard_map_p1",
@@ -251,14 +252,10 @@ class RuntimeConfig:
             if but.value < 12:
                 kbmap[but] = []
             elif but.value < 24:
-                kbmap[but] = self._loaded["keyboard_map_p1"][
-                    but.name.split("_")[1]
-                ]
+                kbmap[but] = self._loaded["keyboard_map_p1"][but.name.split("_")[1]]
 
             elif but.value < 36:
-                kbmap[but] = self._loaded["keyboard_map_p2"][
-                    but.name.split("_")[1]
-                ]
+                kbmap[but] = self._loaded["keyboard_map_p2"][but.name.split("_")[1]]
 
             else:
                 kbmap[but] = []
@@ -271,14 +268,10 @@ class RuntimeConfig:
             if but.value < 12:
                 jsmap[but] = []
             elif but.value < 24:
-                jsmap[but] = self._loaded["joystick_map_p1"][
-                    but.name.split("_")[1]
-                ]
+                jsmap[but] = self._loaded["joystick_map_p1"][but.name.split("_")[1]]
 
             elif but.value < 36:
-                jsmap[but] = self._loaded["joystick_map_p2"][
-                    but.name.split("_")[1]
-                ]
+                jsmap[but] = self._loaded["joystick_map_p2"][but.name.split("_")[1]]
 
             else:
                 jsmap[but] = []

mima/util/trading_item.py

@@ -10,11 +10,14 @@ if TYPE_CHECKING:
 @dataclass
 class TradingItem:
     item: Item
-    price: int
     count: int = 1
     factor: float = 1.0
     available: int = 1
     tid: int = 0
+    price: int = 0
+    trading_price: int = 0
+    stackable: bool = False
+    stackable_merchant: bool = False
 
     def __eq__(self, other):
         return self.tid == other.tid

mima/view/mima_mode.py

@@ -4,7 +4,7 @@ import logging
 import math
 from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
-from ..collision import (
+from ..core.collision import (
     _chunk_index,
     add_to_collision_chunk,
     check_object_to_map_collision,
@@ -141,6 +141,7 @@ class MimaMode(MimaView):
     ) -> None:
         p_obj = self.engine.get_player(player)
         p_obj.stop_shining()
+        p_obj.on_exit_map()
 
         if map_name not in self.players_on_map:
             # Map not loaded
@@ -165,6 +166,7 @@ class MimaMode(MimaView):
         p_obj.tilemap = self.maps[player]
         p_obj.px = px
         p_obj.py = py
+        p_obj.on_enter_map()
         self.engine.memory.last_spawn_px[player] = px
         self.engine.memory.last_spawn_py[player] = py
 
@@ -366,7 +368,10 @@ class MimaMode(MimaView):
         return target  # , skip
 
     def _update_velocity_z(self, obj: Dynamic, elapsed_time: float) -> None:
-        obj.vz -= obj.attributes.gravity_vz * elapsed_time
+        if obj.pz > 0.0:
+            obj.vz -= obj.attributes.gravity_vz * elapsed_time
+        # else:
+        # obj.vz = 0.0
 
     def _update_position_z(self, obj: Dynamic, elapsed_time: float) -> None:
         if obj.gravity:
@@ -385,6 +390,7 @@ class MimaMode(MimaView):
         max_dist = screen_width + screen_height
 
         for map_name, players in self.players_on_map.items():
+            # print(f"Collisions for {map_name}: {self.colliders[map_name]}")
             for obj in self.colliders[map_name]:
                 if obj.occupied:
                     continue

mima/view/mima_scene.py

@@ -39,8 +39,10 @@ class MimaScene(MimaView):
         self._camera_name: str = (
             camera_name if camera_name is not None else f"C_{player.name}"
         )
+        self._controls_camera_name: str = f"{self._camera_name}_CONTROLS"
 
         self.camera: Camera
+        self.controls_camera: Camera
         self._dialog_px: float
         self._dialog_py: float
         self._dialog_width: float = DIALOG_WIDTH
@@ -85,6 +87,9 @@ class MimaScene(MimaView):
             self._dialog_py = height - 4
 
         self.camera = Camera(self._camera_name, width, height)
+        # self.controls_camera = Camera(
+        #     self._controls_camera_name, width, height
+        # )
         if position == Position.CENTER:
             # print(f"Camera setup finished: {width}, {height}")
             return
@@ -181,6 +186,7 @@ class MimaScene(MimaView):
             self.skip_draw_ui = False
             return
         self._current_window.draw_ui()
+        self._current_window.draw_controls()
 
     def draw_camera_border(self):
         self.camera.draw_borders()