mima-engine 0.1.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

mima/collision.py

@@ -1,17 +1,21 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Tuple
+import math
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Tuple
 
 from .maps.tilemap import Tilemap
-from .objects.dynamic import Dynamic
 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 .view.scene import Scene
+    # from .engine import MimaEngine
+    from .objects.dynamic import Dynamic
+    from .states.quest import Quest
+
+    # from .view.view import View
 
 
 def check_object_to_map_collision(
@@ -20,8 +24,10 @@ def check_object_to_map_collision(
     tilemap: Tilemap,
     new_px: float,
     new_py: float,
+    *,
+    layer: int = 0,
+    collision: TileCollision = TileCollision.TOP,
 ) -> Tuple[float, float]:
-
     left = new_px + obj.hitbox_px
     right = left + obj.hitbox_width
     top = obj.py + obj.hitbox_py
@@ -29,7 +35,9 @@ def check_object_to_map_collision(
 
     collided_with_map = False
     if obj.solid_vs_map:
-        if collision_with_map(tilemap, left, right, top, bottom):
+        if collision_with_map(
+            tilemap, left, right, top, bottom, layer, collision
+        ):
             # On rare occasions, the object might be pushed towards
             # the wall, i.e. old and new pos are equal
             # Decide depending on the decimal part of the position
@@ -50,11 +58,7 @@ def check_object_to_map_collision(
             obj.vx = 0
             collided_with_map = True
             if (
-                obj.facing_direction
-                in [
-                    Direction.WEST,
-                    Direction.EAST,
-                ]
+                obj.facing_direction in [Direction.WEST, Direction.EAST]
                 and obj.can_push
             ):
                 obj.lock_graphic_state(GraphicState.PUSHING, Until.NEXT_UPDATE)
@@ -64,7 +68,9 @@ def check_object_to_map_collision(
         top = new_py + obj.hitbox_py
         bottom = top + obj.hitbox_height
 
-        if collision_with_map(tilemap, left, right, top, bottom):
+        if collision_with_map(
+            tilemap, left, right, top, bottom, layer, collision
+        ):
             # See comment above
             if new_py == obj.py:
                 decimal_dif = new_py - int(new_py)
@@ -81,11 +87,7 @@ def check_object_to_map_collision(
             obj.vy = 0
             collided_with_map = True
             if (
-                obj.facing_direction
-                in [
-                    Direction.NORTH,
-                    Direction.SOUTH,
-                ]
+                obj.facing_direction in [Direction.NORTH, Direction.SOUTH]
                 and obj.can_push
             ):
                 obj.lock_graphic_state(GraphicState.PUSHING, Until.NEXT_UPDATE)
@@ -103,124 +105,118 @@ def collision_with_map(
     top: float,
     bottom: float,
     layer: int = 0,
+    collision: TileCollision = TileCollision.TOP,
 ) -> bool:
-    if tilemap.is_solid(left, top, layer):
+    if tilemap.is_solid(left, top, layer, collision):
         return True
-    if tilemap.is_solid(left, bottom, layer):
+    if tilemap.is_solid(left, bottom, layer, collision):
         return True
-    if tilemap.is_solid(right, top, layer):
+    if tilemap.is_solid(right, top, layer, collision):
         return True
-    if tilemap.is_solid(right, bottom, layer):
+    if tilemap.is_solid(right, bottom, layer, collision):
         return True
 
     return False
 
 
 def check_object_to_object_collision(
-    engine: MimaEngine,
-    scene: Scene,
     obj: Dynamic,
     new_px: float,
     new_py: float,
     other: Dynamic,
+    deal_damage: Optional[Callable[Dynamic, Dynamic]] = None,
+    quests: Optional[List[Quest]] = None,
 ) -> Tuple[float, float]:
-    pass
-
-    obj_left = new_px + obj.hitbox_px
-    obj_right = obj_left + obj.hitbox_width
-    obj_top = obj.py + obj.hitbox_py
-    obj_bottom = obj_top + obj.hitbox_height
-
-    other_left = other.px + other.hitbox_px
-    other_right = other_left + other.hitbox_width
-    other_top = other.py + other.hitbox_py
-    other_bottom = other_top + other.hitbox_height
-
-    if obj.solid_vs_dyn and other.solid_vs_dyn:
-        collided_with_dyn = False
-        if collision_with_dyn(
-            obj_left,
-            obj_right,
-            obj_top,
-            obj_bottom,
-            other_left,
-            other_right,
-            other_top,
-            other_bottom,
-        ):
-            collided_with_dyn = True
-            if obj_left < other_left:
-                new_px -= obj_right - other_left + 0.001
-            else:
-                new_px += other_right - obj_left + 0.001
-
-        obj_left = new_px + obj.hitbox_px
-        obj_right = obj_left + obj.hitbox_width
-        obj_top = new_py + obj.hitbox_py
-        obj_bottom = obj_top + obj.hitbox_height
-
-        if collision_with_dyn(
-            obj_left,
-            obj_right,
-            obj_top,
-            obj_bottom,
-            other_left,
-            other_right,
-            other_top,
-            other_bottom,
-        ):
-            collided_with_dyn = True
-            if obj_top < other_top:
-                new_py -= obj_bottom - other_top + 0.001
-            else:
-                new_py += other_bottom - obj_top + 0.001
+    quests = quests if quests is not None else []
+    deal_damage = deal_damage if deal_damage is not None else lambda x, y: None
 
-        if collided_with_dyn:
-            other.on_interaction(obj, Nature.WALK)
+    pxys = {}
+    pxys["left1"] = new_px + obj.hitbox_px
+    pxys["right1"] = pxys["left1"] + obj.hitbox_width
+    pxys["top1"] = obj.py + obj.hitbox_py
+    pxys["bottom1"] = pxys["top1"] + obj.hitbox_height
+
+    pxys["left2"] = other.px + other.hitbox_px
+    pxys["right2"] = pxys["left2"] + other.hitbox_width
+    pxys["top2"] = other.py + other.hitbox_py
+    pxys["bottom2"] = pxys["top2"] + other.hitbox_height
+
+    if obj.solid_vs_dyn and other.solid_vs_dyn:  # and obj.moves_on_collision:
+        new_px, new_py = _check_solid_objects(obj, other, new_px, new_py, pxys)
 
     else:
         if obj.type == ObjectType.PLAYER:
-            if collision_with_dyn(
-                obj_left,
-                obj_right,
-                obj_top,
-                obj_bottom,
-                other_left,
-                other_right,
-                other_top,
-                other_bottom,
-            ):
-                for quest in engine.quests:
-                    if quest.on_interaction(
-                        scene.dynamics, other, Nature.WALK
-                    ):
-                        break
-                scene.tilemap.on_interaction(other, Nature.WALK)
-                other.on_interaction(obj, Nature.WALK)
+            _check_player_with_non_solid(obj, other, pxys, quests)
+
         else:
-            if collision_with_dyn(
-                obj_left,
-                obj_right,
-                obj_top,
-                obj_bottom,
-                other_left,
-                other_right,
-                other_top,
-                other_bottom,
-            ):
-                if obj.type == ObjectType.PROJECTILE:
-                    if other.alignment != obj.alignment:
-                        # We know object is a projectile
-                        if other.attackable and not other.invincible:
-                            scene.deal_damage(obj, other)
-                        else:
-                            other.on_interaction(obj, Nature.WALK)
-                else:
-                    other.on_interaction(obj, Nature.WALK)
+            _check_non_solid_objects(obj, other, pxys, deal_damage)
 
     return new_px, new_py
 
 
+def _check_solid_objects(
+    obj: Dynamic,
+    other: Dynamic,
+    new_px: float,
+    new_py: float,
+    pxys: Dict[str, float],
+) -> None:
+    collided_with_dyn = False
+    if collision_with_dyn(**pxys):
+        collided_with_dyn = True
+        if pxys["left1"] < pxys["left2"]:
+            new_px -= pxys["right1"] - pxys["left2"] + 0.001
+        else:
+            new_px += pxys["right2"] - pxys["left1"] + 0.001
+
+    pxys["left1"] = new_px + obj.hitbox_px
+    pxys["right1"] = pxys["left1"] + obj.hitbox_width
+    pxys["top1"] = new_py + obj.hitbox_py
+    pxys["bottom1"] = pxys["top1"] + obj.hitbox_height
+
+    if collision_with_dyn(**pxys):
+        collided_with_dyn = True
+        if pxys["top1"] < pxys["top2"]:
+            new_py -= pxys["bottom1"] - pxys["top2"] + 0.001
+        else:
+            new_py += pxys["bottom2"] - pxys["top1"] + 0.001
+
+    if collided_with_dyn:
+        # print(f"Collision: {obj.get_player()} -> {other.dyn_id}")
+        other.on_interaction(obj, Nature.WALK)
+
+    return new_px, new_py
+
+
+def _check_player_with_non_solid(
+    obj: Dynamic, other: Dynamic, pxys: Dict[str, float], quests: List[Quest]
+):
+    if collision_with_dyn(**pxys):
+        for quest in quests:
+            if quest.on_interaction(other, Nature.WALK, obj.get_player()):
+                break
+        obj.tilemap.on_interaction(other, Nature.WALK)
+        other.on_interaction(obj, Nature.WALK)
+
+
+def _check_non_solid_objects(
+    obj: Dynamic,
+    other: Dynamic,
+    pxys: Dict[str, float],
+    deal_damage: Callable[Dynamic, Dynamic],
+):
+    if collision_with_dyn(**pxys):
+        if obj.type == ObjectType.PROJECTILE:
+            if other.alignment != obj.alignment:
+                # We know object is a projectile
+                if other.attackable and not other.invincible:
+                    deal_damage(obj, other)
+                else:
+                    other.on_interaction(obj, Nature.WALK)
+        else:
+            other.on_interaction(obj, Nature.WALK)
+
+
 def collision_with_dyn(
     left1: float,
     right1: float,
@@ -235,3 +231,78 @@ def collision_with_dyn(
         return True
 
     return False
+
+
+def add_to_collision_chunk(
+    collision_chunks: Dict[int, List[Dynamic]],
+    obj: Dynamic,
+    chunk_size: int,
+    chunks_per_row: int,
+) -> List[int]:
+    chunk_ids = []
+    # chidx = _chunk_index(obj.px, obj.py, chunk_size, chunks_per_row)
+    # collision_chunks.setdefault(chidx, [])
+
+    # if obj not in collision_chunks[chidx]:
+    #     if obj.get_player().value > 0:
+    #         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:
+        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 (
+            chid not in chunk_ids
+            and chid in collision_chunks
+            and obj in collision_chunks[chid]
+        ):
+            collision_chunks[chid].remove(obj)
+    return chunk_ids
+
+
+def _test_chunk_position(
+    collision_chunks, obj, px, py, chunk_size, chunks_per_row
+):
+    chidx = _chunk_index(px, py, chunk_size, chunks_per_row)
+    collision_chunks.setdefault(chidx, [])
+
+    if obj not in collision_chunks[chidx]:
+        if obj.get_player().value > 0:
+            collision_chunks[chidx].insert(0, obj)
+        else:
+            collision_chunks[chidx].append(obj)
+    return chidx
+
+
+def _chunk_index(px, py, chunk_size, chunks_per_row):
+    hc = chunk_size // 2
+    return math.floor((px + hc) / chunk_size) + chunks_per_row * math.floor(
+        (py + hc) / chunk_size
+    )

mima/engine.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 from abc import ABC, abstractmethod
-from typing import Dict
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from .backend.pygame_assets import PygameAssets
 from .backend.pygame_audio import PygameAudio
@@ -13,16 +13,26 @@ 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.scene import Scene
+
+# from .view.game_mode import GameMode
+from .view.mima_view import MimaView
+
+# from .view.scene import Scene
+
+if TYPE_CHECKING:
+    from .states.game_state import GameState
 
 LOG = logging.getLogger(__name__)
 
@@ -54,9 +64,13 @@ class MimaEngine(ABC):
         self.gate_color: GateColor = GateColor.RED
         self.n_gate_colors = 2
         self.script: ScriptProcessor = None
-        self.player: Creature
-        self.quests: List[Quest] = []
-        self._items: Dict[str, Item] = {}
+        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(
         self,
@@ -66,26 +80,35 @@ class MimaEngine(ABC):
         fullscreen: bool = False,
         target_fps: int = 60,
         resizable: bool = False,
+        kb_map=None,
     ):
         """Initialize backend and create a window."""
         AnimatedSprite.engine = self
         Camera.engine = self
         Command.engine = self
         Dynamic.engine = self
+        # GameMode.engine = self
+        Item.engine = self
         PygameBackend.engine = self
+        ObjectLoader.engine = self
         Quest.engine = self
-        Scene.engine = self
+        # Scene.engine = self
         ScriptProcessor.engine = self
         Sprite.engine = self
         Template.engine = self
         Tilemap.engine = self
-        Item.engine = self
+        MimaView.engine = self
 
         self.script = ScriptProcessor()
-        self.backend.init()
+        self.backend.init(
+            keyboard_map=self.rtc.get_keyboard_map(),
+            joystick_map=self.rtc.get_joystick_map(),
+            joy_to_player=self.rtc.get_joy_to_player(),
+        )
         self.backend.construct(
             width, height, pixel_size, fullscreen, target_fps, resizable
         )
+
         return True
 
     def start(self):
@@ -101,18 +124,20 @@ class MimaEngine(ABC):
         if self.on_user_create():
             while self.backend.keep_running():
                 self.backend.set_caption(
-                    f"{self._caption} ({self.game_fps:.2f}/{self.app_fps:.2f} fps)"
+                    f"{self._caption} ({self.game_fps:.2f}/"
+                    f"{self.app_fps:.2f} fps)"
                 )
                 self.backend.process_events()
 
                 if not self.backend.keep_running():
                     break
 
+                self.cameras = ["display"]
                 if not self.on_user_update(self.elapsed_time):
                     print("Error in on_user_update")
                     break
 
-                self.backend.update_display()
+                self.backend.update_display(*self.cameras)
 
                 self._app_time = self.backend.tick()
                 self.elapsed_time = min(self._app_time, 1.0 / 30.0)
@@ -135,11 +160,13 @@ class MimaEngine(ABC):
                     app_seconds -= 1.0
 
             print(
-                f"App/Game Frames total: {app_frames_total}/{game_frames_total}"
+                f"App/Game Frames total: {app_frames_total}/"
+                f"{game_frames_total}"
             )
             print(f"Seconds total: {self.seconds_total:.3f}")
             print(
-                f"Average App/Game FPS: {app_frames_total/self.seconds_total:.3f}/"
+                "Average App/Game FPS: "
+                f"{app_frames_total/self.seconds_total:.3f}/"
                 f"{game_frames_total/self.seconds_total:.3f}"
             )
 
@@ -175,15 +202,41 @@ class MimaEngine(ABC):
 
     def load_item(self, item: Item):
         LOG.debug(f"Loading item  {item.name}.")
-        self._items[item.name] = item
+        self.memory.items[item.name] = item
 
     def get_item(self, item_id: str):
         try:
-            return self._items[item_id]
+            return self.memory.items[item_id]
         except KeyError:
-            LOG.error(f"Item '{item_id}' is not defined!")
+            LOG.exception(f"Item '{item_id}' is not defined!")
+            raise
+        except TypeError:
+            print(type(self.memory.items), item_id)
             raise
 
+    def give_item(self, item: Union[str, Item], player: Player = Player.P1):
+        if isinstance(item, str):
+            item = self.get_item(item)
+        self.memory.bag[player].append(item)
+        # self.items.append(item)
+        return True
+
+    def take_item(self, item: Union[str, Item], player: Player = Player.P1):
+        if isinstance(item, str):
+            item = self.get_item(item)
+
+        if item in self.memory.bag[player]:
+            self.memory.bag[player].remove(item)
+            return True
+        return False
+
+    def has_item(self, item: Union[str, Item], player: Player = Player.P1):
+        if isinstance(item, str):
+            item = self.get_item(item)
+
+        return item in self.memory.bag[player]
+        # return False
+
     def progress_quest(self, quest_name: str, new_state: int):
         for quest in self.quests:
             if quest.name == quest_name:
@@ -200,3 +253,90 @@ class MimaEngine(ABC):
 
     def on_entered_foreground(self):
         LOG.debug("Entered foreground")
+
+    def get_player(self, player: Player = Player.P1):
+        if player in self.memory.player:
+            return self.memory.player[player]
+        else:
+            return None
+
+    def set_player(self, creature: Creature, player: Player = Player.P1):
+        self.memory.player[player] = creature
+
+    def trigger_teleport(
+        self, active: bool = True, player: Player = Player.P1
+    ):
+        self.memory.teleport_active[player] = active
+
+    def is_teleport_active(self, player: Player = Player.P1):
+        return self.memory.teleport_active[player]
+
+    def trigger_dialog(self, active: bool = True, player=Player.P1):
+        self.memory.dialog_active[player] = active
+
+    def is_dialog_active(self, player: Player = Player.P1):
+        return self.memory.dialog_active[player]
+
+    def trigger_script(
+        self, active: bool = True, player: Player = Player.P1
+    ) -> None:
+        self.memory.script_active[player] = active
+
+    def is_script_active(self, player: Player = Player.P1) -> bool:
+        return self.memory.script_active[player]
+
+    def trigger_player_collision(
+        self, active: bool = True, player: Player = Player.P1
+    ) -> None:
+        self.memory.player_collision_active[player] = active
+
+    def is_player_collision_active(self, player: Player = Player.P1) -> bool:
+        return self.memory.player_collision_active[player]
+
+    @property
+    def player(self):
+        print("Deprecated access to player. Use 'get_player' instead!")
+        return self.memory.player
+
+    @player.setter
+    def player(self, val):
+        print("Deprecated access to player. Use 'get_player' instead!")
+        self.memory.player = val
+
+    @property
+    def items(self):
+        # raise TypeError()
+        return self.memory.items
+
+    @items.setter
+    def items(self, val):
+        raise TypeError(f"Items cannot be set to type {type(val)}")
+        # self.memory.items = val
+
+    @property
+    def quests(self):
+        return self.memory.quests
+
+    @quests.setter
+    def quests(self, val):
+        self.memory.quests = val
+
+    @property
+    def dialog_active(self):
+        print("dialog_active is deprecated; use 'is_dialog_active()' instead.")
+        return self.memory.dialog_active
+
+    @dialog_active.setter
+    def dialog_active(self, val):
+        print(
+            "dialog_active is deprecated; use "
+            "'trigger_dialog(active)' instead."
+        )
+        self.memory.dialog_active = val
+
+    @property
+    def game_state(self) -> GameState:
+        return self.all_games[self.current_game]
+
+    def get_view(self):
+        return None

mima/maps/tiled/tiled_map.py

@@ -5,11 +5,11 @@ import os
 from typing import List
 from xml.etree import ElementTree
 
+from ...util.property import Property
 from ..tilemap import Tilemap
 from ..tileset_info import TilesetInfo
 from .tiled_layer import TiledLayer
 from .tiled_objectgroup import TiledObjectgroup
-from ...util.property import Property
 
 # if TYPE_CHECKING:
 #     from ..engine import Avare
@@ -59,7 +59,7 @@ class TiledMap(Tilemap):
                 self.properties[pname] = Property(
                     name=pname,
                     dtype=p.attrib.get("type", "str"),
-                    value=p.attrib["value"]
+                    value=p.attrib["value"],
                 )
 
         LOG.debug("Loading tilesets ...")
@@ -92,4 +92,4 @@ class TiledMap(Tilemap):
         for group in self._objects:
             all_objects += group.objects
 
-        return all_objects
+        return all_objects

mima/maps/tiled/tiled_tileset.py

@@ -39,6 +39,7 @@ class TiledTileset(Tileset):
 
         LOG.debug("Loading tiles ...")
         tiles = root.findall("tile")
+        
         for tile in tiles:
             self.tiles.append(TiledTile(tile))
             if self.tiles[-1].animated: