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

mima/maps/tilemap.py

@@ -4,11 +4,11 @@ import logging
 import math
 from typing import TYPE_CHECKING, Dict, List, Optional
 
-from ..util.constants import TILE_HEIGHT, TILE_WIDTH
+from ..types.tile_collision import TileCollision
+from .template import Template
 from .tile_info import TileInfo
 from .tile_layer import TileLayer
 from .tileset_info import TilesetInfo
-from .template import Template
 
 if TYPE_CHECKING:
     from ..objects.dynamic import Dynamic
@@ -20,17 +20,17 @@ LOG = logging.getLogger(__name__)
 
 
 class Tilemap(Template):
-
     def __init__(self, name: str):
         super().__init__(name)
         self.width: int = 0
         self.height: int = 0
-        self.tile_width = TILE_WIDTH
-        self.tile_height = TILE_HEIGHT
+        self.tile_width = self.engine.rtc.tile_width
+        self.tile_height = self.engine.rtc.tile_height
 
         self._layers: List[TileLayer] = []
         self._tilesets: List[TilesetInfo] = []
         self._cache: Dict[int, TileInfo] = {}
+        self._objects: List[Template] = []
 
     def populate_dynamics(self, dynamics: List[Dynamic]) -> bool:
         """Load all map-related objects into the game."""
@@ -54,6 +54,7 @@ class Tilemap(Template):
         visible_tiles_ex: int,
         visible_tiles_ey: int,
         layer_pos: int = 0,
+        camera_name: str = "display",
     ):
         # Get offsets for smooth movement
         tile_ox = (ox - math.floor(ox)) * self.tile_width
@@ -79,13 +80,12 @@ class Tilemap(Template):
                 layer_visible_tiles_sy -= 1
 
             # Draw visible tiles of the map
-            for x in range(layer_visible_tiles_sx, int(visible_tiles_ex) + 1):
+            for x in range(layer_visible_tiles_sx, int(visible_tiles_ex) + 2):
                 for y in range(
-                    layer_visible_tiles_sy, int(visible_tiles_ey) + 1
+                    layer_visible_tiles_sy, int(visible_tiles_ey) + 2
                 ):
                     tile_index = layer.get_index(
-                        int(x + math.floor(ox)),
-                        int(y + math.floor(oy)),
+                        int(x + math.floor(ox)), int(y + math.floor(oy))
                     )
                     if tile_index <= 0:
                         # Zero means the tile was not set in Tiled
@@ -108,6 +108,7 @@ class Tilemap(Template):
                         sy * self.tile_height,
                         self.tile_width,
                         self.tile_height,
+                        camera_name,
                     )
         return True
 
@@ -115,17 +116,56 @@ class Tilemap(Template):
         return False
 
     def is_solid(
-        self, px: int, py: int, layer_pos: Optional[int] = None
+        self,
+        px: int,
+        py: int,
+        layer_pos: Optional[int] = None,
+        collision: TileCollision = TileCollision.TOP,
     ) -> bool:
-        tile = self.get_tile(px, py, layer_pos)
-        if tile is not None and tile.solid:
-            return True
+        if collision in (TileCollision.TOP, TileCollision.BOTTOM):
+            tile = self.get_tile(
+                px,
+                py,
+                layer_pos,
+                ascending=(collision == TileCollision.BOTTOM),
+            )
+
+            if tile is not None and tile.solid:
+                return True
+            return False
+
+        tiles = self.get_tiles(px, py, layer_pos)
+        if collision in (TileCollision.TOP_2, TileCollision.TOP_3):
+            tiles = tiles[::-1]
+
+        for idx, tile in enumerate(self.get_tiles(px, py, layer_pos)):
+            if tile.solid:
+                return True
+            if idx == 1 and collision in (
+                TileCollision.TOP_2,
+                TileCollision.BOTTOM_2,
+            ):
+                break
+            elif idx == 2 and collision in (
+                TileCollision.TOP_3,
+                TileCollision.BOTTOM_3,
+            ):
+                break
         return False
 
     def get_tile(
-        self, px: int, py: int, layer_pos: Optional[int] = None
+        self,
+        px: int,
+        py: int,
+        layer_pos: Optional[int] = None,
+        ascending=False,
     ) -> Optional[Tile]:
-        for layer in self._layers[::-1]:
+        if ascending:
+            layers = self._layers
+        else:
+            layers = self._layers[::-1]
+
+        for layer in layers:
             if layer_pos is not None and layer_pos != layer.layer_pos:
                 continue
             tile_index = layer.get_index(math.floor(px), math.floor(py))
@@ -139,6 +179,21 @@ class Tilemap(Template):
 
         return None
 
+    def get_tiles(self, px: int, py: int, layer_pos: Optional[int] = None):
+        tiles = []
+        for layer in self._layers:
+            if layer_pos is not None and layer_pos != layer.layer_pos:
+                continue
+            tile_index = layer.get_index(math.floor(px), math.floor(py))
+            if tile_index not in self._cache:
+                if not self._load_to_cache(tile_index):
+                    continue
+            info = self._cache[tile_index]
+            if info.tile is not None:
+                tiles.append(info.tile)
+
+        return tiles
+
     def _load_to_cache(self, tile_index: int) -> bool:
         tileset = None
         firstgid = 0
@@ -157,3 +212,11 @@ class Tilemap(Template):
 
         self._cache[tile_index] = TileInfo(tileset=tileset, tile=tile)
         return True
+
+    def trigger_new_frame(self):
+        for tsinfo in self._tilesets:
+            tsinfo.tileset.trigger_new_frame()
+
+    @property
+    def objects(self) -> List[Template]:
+        return []

mima/maps/tileset.py

@@ -17,10 +17,13 @@ class Tileset:
 
         self.tiles: List[Tile] = []
         self.animated_tiles: List[Tile] = []
+        self._is_new_frame: bool = False
 
     def update(self, elapsed_time: float) -> bool:
-        for tile in self.animated_tiles:
-            tile.update(elapsed_time)
+        if self._is_new_frame:
+            for tile in self.animated_tiles:
+                tile.update(elapsed_time)
+            self._is_new_frame = False
 
         return True
 
@@ -30,3 +33,6 @@ class Tileset:
                 return tile
 
         return self.tiles[0]
+
+    def trigger_new_frame(self):
+        self._is_new_frame = True

mima/maps/transition_map.py

@@ -5,8 +5,6 @@ from typing import TYPE_CHECKING, Optional
 from ..util.constants import (
     MAP_TRANSITION_DURATION_FACTOR,
     MOVE_MAP_DURATION,
-    TILE_HEIGHT,
-    TILE_WIDTH,
     UI_HIGHT,
 )
 from .tilemap import Tilemap
@@ -35,18 +33,18 @@ class TransitionMap(Tilemap):
 
         self.width: int = self.src_map.width
         self.height: int = self.src_map.height
-        self.tiles_nx = self.engine.backend.render_width / TILE_WIDTH
-        self.tiles_ny = self.engine.backend.render_height / TILE_HEIGHT
+        self.tiles_nx = (
+            self.engine.backend.render_width / self.engine.rtc.tile_width
+        )
+        self.tiles_ny = (
+            self.engine.backend.render_height / self.engine.rtc.tile_height
+        )
 
         if self.vx != 0:
             self.step_size = self.duration / (self.tiles_nx * 0.75)
         elif self.vy != 0:
             self.step_size = self.duration / ((self.tiles_ny - 1) * 0.75)
 
-        # print(
-        #     f"Step Size={self.step_size}, Duration={self.duration}, Size={WIDTH, HEIGHT}, TileSize={TILE_WIDTH, TILE_HEIGHT} "
-        # )
-
     def update(self, elapsed_time: float) -> bool:
         self.progress = self.time_so_far / self.step_size
         self.time_so_far += elapsed_time

mima/mode_engine.py

@@ -0,0 +1,80 @@
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+
+from .engine import MimaEngine
+from .states.game_state import GameState
+from .types.keys import Key as K
+from .types.mode import Mode
+from .types.nature import Nature
+from .types.player import Player
+from .view.mima_mode import MimaMode
+
+# from .view.mima_scene import MimaScene
+LOG = logging.getLogger(__name__)
+
+
+class MimaModeEngine(MimaEngine):
+    def __init__(
+        self,
+        init_file: str,
+        config_path: str,
+        default_config: Dict[str, Any],
+        platform="PC",
+        caption: str = "MimaEngine",
+    ):
+        super().__init__(
+            init_file, config_path, default_config, platform, caption
+        )
+
+        self.modes: Dict[Mode, MimaMode] = {}
+        self.mode: Optional[MimaMode] = None
+
+        self.mode_stack: List[Mode] = []
+
+        self.draw_chunks: bool = False
+        self.draw_chunk_info: bool = False
+        self.disable_filter: bool = False
+        self._timer = 1.0
+
+    def on_user_create(self):
+        # change_mode(Mode.LOADING)
+        # TODO add example modes
+        return True
+
+    def on_user_update(self, elapsed_time: float):
+        self.audio.update(elapsed_time)
+
+        # print("Update start")
+
+        if not self.mode.update(elapsed_time):
+            LOG.critical(f"Update of mode {self.mode} failed.")
+            return False
+        self._timer -= elapsed_time
+        if self._timer <= 0.0:
+            self._timer += 1.0
+            LOG.debug(
+                f"Updated {self.mode} (Current Stack:"
+                f"{[m.name for m in self.mode_stack]})"
+            )
+        # print("Update end")
+        return True
+
+    def change_mode(self, mode: Mode):
+        if mode in self.mode_stack:
+            self.mode_stack.remove(mode)
+        self.mode_stack.append(mode)
+        if self.mode is not None:
+            self.mode.unload()
+        self.mode = self.modes[mode]
+        self.mode.load()
+
+    def return_mode(self):
+        LOG.debug(
+            "Returning to previous mode. Stack: %s", str(self.mode_stack)
+        )
+        self.mode_stack.pop()
+        self.mode = self.modes[self.mode_stack[-1]]
+        self.mode.load()
+
+    def get_view(self):
+        return self.mode

mima/objects/animated_sprite.py

@@ -4,7 +4,6 @@ from typing import Any, Dict, Optional
 
 from ..types.direction import Direction
 from ..types.graphic_state import GraphicState
-from ..util.constants import TILE_HEIGHT, TILE_WIDTH
 
 LOG = logging.getLogger(__name__)
 
@@ -35,7 +34,7 @@ class AnimatedSprite:
                     "tileset": tileset_name,
                     "image": image_name,
                     "sprite": self._sprite_name,
-                },
+                }
             )
             tileset = self.engine.assets.get_tileset(tileset_name)
 
@@ -56,9 +55,11 @@ class AnimatedSprite:
             self._timer: float = data["duration"][0]
         else:
             LOG.debug(
-                f"Sprite information uncomplete. Tileset={tileset_name}, Image"
-                f"={image_name}, Sprite={self._sprite_name}. Will continue without "
-                "sprite."
+                "Sprite information uncomplete. Tileset=%s, Image=%s, Sprite="
+                "%s. Will continue without sprite.",
+                tileset_name,
+                image_name,
+                self._sprite_name,
             )
             self.name = self._tileset_name = self._sprite_name = ""
 
@@ -103,14 +104,20 @@ class AnimatedSprite:
         self._last_direction = direction
         self._last_graphic_state = graphic_state
 
-    def draw_self(self, px: float, py: float, absolute_position: bool = False):
+    def draw_self(
+        self,
+        px: float,
+        py: float,
+        camera_name: str = "display",
+        absolute_position: bool = False,
+    ):
         if self.name == "":
             return
 
         data = self._get_data(self._last_graphic_state, self._last_direction)
         if not absolute_position:
-            px *= TILE_WIDTH
-            py *= TILE_HEIGHT
+            px *= self.engine.rtc.tile_width
+            py *= self.engine.rtc.tile_height
         px, py = math.floor(px), math.floor(py)
         try:
             self.engine.backend.draw_partial_sprite(
@@ -121,8 +128,9 @@ class AnimatedSprite:
                 data["oy"][self._frame_index] * self.height,
                 self.width,
                 self.height,
+                camera_name,
             )
-        except KeyError as err:
+        except KeyError:
             LOG.exception(
                 f"Data of {self._tileset_name, self.name} is malformed: {data}"
             )
@@ -180,15 +188,15 @@ class AnimatedSprite:
         data = self._sprites.get(
             graphic_state, self._sprites.get(GraphicState.STANDING, {})
         )
-        data = data.get(
-            direction,
-            data.get(Direction.SOUTH, {}),
-        )
+        data = data.get(direction, data.get(Direction.SOUTH, {}))
         if not data:
             try:
                 LOG.debug(
-                    f"Animation of sprite {self._tileset_name,self._sprite_name}"
-                    f" is empty for {graphic_state.name, direction.name} "
+                    "Animation of sprite %s,%s is empty for %s, %s ",
+                    self._tileset_name,
+                    self._sprite_name,
+                    graphic_state.name,
+                    direction.name,
                 )
             except Exception:
                 # print(graphic_state, direction)

mima/objects/attributes.py

@@ -77,6 +77,9 @@ class Attributes:
         self.wisdom: int = 0
         self.initiative: int = 0
 
+        self.sell_factor: float = 1.0
+        self.buy_factor: float = 1.0
+
         self.experience: int = 0
         self.defense: Dict[Damage, int] = {dt: 0 for dt in Damage}
 

mima/objects/creature.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional
 
 from ..types.direction import Direction
 from ..types.graphic_state import GraphicState, Until
 from ..types.nature import Nature
 from ..types.object import ObjectType
+from ..types.player import Player
 from ..types.terrain import Terrain
 from ..types.weapon_slot import WeaponSlot
 
@@ -14,28 +15,35 @@ from ..util.colors import BLACK
 from ..util.constants import DEFAULT_KNOCK_SPEED
 from .animated_sprite import AnimatedSprite
 from .dynamic import Dynamic
+from .effects.light import Light
 from .effects.walking_on_grass import WalkingOnGrass
 from .effects.walking_on_water import WalkingOnWater
 from .projectile import Projectile
 
-# if TYPE_CHECKING:
-#     from ..usables.weapon import Weapon
+if TYPE_CHECKING:
+    from ..maps.tilemap import Tilemap
+    from ..usables.weapon import Weapon
+    from ..util.trading_item import TradingItem
 
 
 class Creature(Dynamic):
     def __init__(
         self,
-        name: str,
-        tileset_name: str,
-        image_name: str,
-        sprite_name: str,
-        px: float,
-        py: float,
+        px: float = 0,
+        py: float = 0,
+        name: str = "Unnamed Creature",
+        *,
+        tilemap: Tilemap = None,
         dyn_id: int = -1,
+        tileset_name: str = "",
+        image_name: str = "",
+        sprite_name: str = "",
+        player: Player = Player.P0,
     ):
-        super().__init__(name, px, py, dyn_id)
+        super().__init__(px, py, name, tilemap, dyn_id)
 
         self.sprite = AnimatedSprite(tileset_name, image_name, sprite_name)
+        self.player = player
         self.type = ObjectType.CREATURE
         self.knock_speed: float = DEFAULT_KNOCK_SPEED
 
@@ -43,6 +51,7 @@ class Creature(Dynamic):
         # self.sprite.num_frames = 2
         self.attackable = True
         self.knockable = True
+        self.moves_on_collision = True
 
         self._knock_vx: float = 0.0
         self._knock_vy: float = 0.0
@@ -64,9 +73,23 @@ class Creature(Dynamic):
             WeaponSlot.FIRST_HAND: None,
             WeaponSlot.SECOND_HAND: None,
         }
+        self._light = None
 
-    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        self.attributes.speed = 5.0
+        # self.use_acceleration = True
+        # self.use_friction = True
+        # self.attributes.friction = 0.1
+
+    def start_shining(self):
+        self._light = Light(self, fixed_size=True, update_from_target=True)
+        self.engine.get_view().add_effect(self._light, self.tilemap.name)
 
+    def stop_shining(self):
+        if self._light is not None:
+            self._light.kill()
+            self._light = None
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
         if not self.visible:
             self.vx = self.vy = 0.0
             return
@@ -89,6 +112,7 @@ class Creature(Dynamic):
                 self._invincible_timer -= elapsed_time
             if self._invincible_timer <= 0.0:
                 self.invincible = False
+                self.knockable = True
                 self._invincible_timer = 0.0
 
             if self._attack_timer > 0.0:
@@ -159,7 +183,7 @@ class Creature(Dynamic):
         if self._gs_lock_condition == Until.NEXT_UPDATE:
             self.graphic_state_locked = False
 
-    def draw_self(self, ox: float, oy: float):
+    def draw_self(self, ox: float, oy: float, camera_name: str = "display"):
         if (
             self.sprite.name is None
             or self.sprite.name == ""
@@ -176,9 +200,10 @@ class Creature(Dynamic):
                 py + 0.7 * self.sprite.height,
                 0.3125 * self.sprite.width,
                 BLACK,
+                camera_name,
             )
 
-        self.sprite.draw_self(px, py - self.pz)
+        self.sprite.draw_self(px, py - self.pz, camera_name)
         # for effect in self.effects:
         #     effect.draw_self(px, py - self.pz)
 
@@ -203,7 +228,9 @@ class Creature(Dynamic):
             self._knock_vx = vx
             self._knock_vy = vy
             self._knock_timer = dist
-            self.invincible_timer = dist + 0.2
+
+            self.knockable = False
+            self._invincible_timer = dist + 0.5
             # self.solid_vs_dyn = False
             self.controllable = False
             self.invincible = True
@@ -273,9 +300,11 @@ class Creature(Dynamic):
                     if do.inherit_pos:
                         do.px = self.px
                         do.py = self.py
-                    self.engine.scene.add_projectile(do)
+                    self.engine.get_view().add_projectile(
+                        do, self.tilemap.name
+                    )
                 else:
-                    self.engine.scene.add_dynamic(do)
+                    self.engine.get_view().add_dynamic(do, self.tilemap.name)
 
         self.spawn_on_death = []
 
@@ -304,7 +333,7 @@ class Creature(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
 
@@ -318,6 +347,8 @@ class Creature(Dynamic):
         for s, w in self.weapons.items():
             if slot != s and weapon == w:
                 # Weapon equipped in a different slot; change
+                if self.weapons[slot] is not None:
+                    self.weapons[slot].on_unequip(self)
                 self.weapons[slot] = weapon
                 self.weapons[s] = None
                 return
@@ -332,3 +363,9 @@ class Creature(Dynamic):
     def unequip_weapon(self, slot):
         if self.weapons[slot] is not None:
             self.weapons[slot].on_unequip(self)
+
+    def get_trading_items(self) -> List[TradingItem]:
+        return []
+
+    def __str__(self):
+        return f"C({self.name}, {self.dyn_id})"

mima/objects/dynamic.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, List, Optional, Union
 
 from ..types.alignment import Alignment
 from ..types.damage import Damage
@@ -8,13 +8,15 @@ from ..types.direction import Direction
 from ..types.graphic_state import GraphicState, Until
 from ..types.nature import Nature
 from ..types.object import ObjectType
+from ..types.player import Player
 from ..types.terrain import Terrain
-from .attributes import Attributes
 from .attribute_effect import Effect
+from .attributes import Attributes
 from .sprite import Sprite
 
 if TYPE_CHECKING:
     from ..engine import MimaEngine
+    from ..maps.tilemap import Tilemap
     from .projectile import Projectile
 
 
@@ -23,17 +25,20 @@ class Dynamic:
 
     def __init__(
         self,
-        name: str = "Unnamed Dynamic",
         px: float = 0.0,
         py: float = 0.0,
+        name: str = "Unnamed Dynamic",
+        tilemap: Optional[Tilemap] = None,
         dyn_id=-1,
     ):
         self.name: str = name
         self.dyn_id: int = dyn_id  # ID given by Tiled
         self.layer: int = 1
+        self.tilemap = tilemap  # The object's current map
+        self.player = Player.P0
 
-        self.px: float = px
-        self.py: float = py
+        self.px: float = px if px is not None else 0.0
+        self.py: float = py if py is not None else 0.0
         self.pz: float = 0.0
         self.vx: float = 0.0
         self.vy: float = 0.0
@@ -52,6 +57,7 @@ class Dynamic:
 
         self.solid_vs_map: bool = True
         self.solid_vs_dyn: bool = True
+        self.solid_vs_player: bool = True
         # self.is_player: bool = False
         # self.is_projectile: bool = False
         self.redundant: bool = False
@@ -64,6 +70,7 @@ class Dynamic:
         self.graphic_state_locked: bool = False
         self.use_acceleration: bool = False
         self.use_friction: bool = False
+        self.occupied: bool = False
 
         self.alignment: Alignment = Alignment.GOOD
         self.walking_on: Terrain = Terrain.DEFAULT
@@ -86,7 +93,10 @@ class Dynamic:
 
         self.sprite: Sprite = Sprite()
 
-        # Performance flags
+        # Performance
+        self.chunks: List[int] = []
+        self.moves_on_collision: bool = False
+
         self.update_skippable: bool = False
         """Update may be skipped if object is offscreen."""
         self.offscreen_collision_skippable: bool = True
@@ -100,7 +110,7 @@ class Dynamic:
         """Update this dynamic."""
         pass
 
-    def draw_self(self, ox: float, oy: float):
+    def draw_self(self, ox: float, oy: float, camera_name: str = "display"):
         """Draw self to screen"""
         pass
 
@@ -154,7 +164,6 @@ class Dynamic:
         if isinstance(eff, str):
             obj = [e for e in self.attribute_effects if e.effect_id == eff]
             if not obj:
-                print("Effect not active")
                 return
             else:
                 eff = obj[0]
@@ -180,3 +189,16 @@ class Dynamic:
             rad += eff.light_radius
 
         return rad
+
+    def get_player(self):
+        return self.player
+
+    def halt(self):
+        self.vx = 0
+        self.vy = 0
+
+    def __str__(self):
+        return f"D({self.name}, {self.dyn_id})"
+
+    def __repr__(self):
+        return str(self)