mima-engine 0.4.0__py3-none-any.whl

mima/objects/animated_sprite.py

@@ -0,0 +1,217 @@
+import logging
+import math
+from typing import Any, Dict, Optional
+
+from ..types.direction import Direction
+from ..types.graphic_state import GraphicState
+
+LOG = logging.getLogger(__name__)
+
+
+class AnimatedSprite:
+    engine = None
+    sprite_sets = {}
+
+    def __init__(
+        self,
+        # tileset_name: str,
+        # image_name: str,
+        sprite_name: str,
+        graphic_state: GraphicState = GraphicState.STANDING,
+        facing_direction: Direction = Direction.SOUTH,
+    ):
+
+        self.name = sprite_name
+        self._last_direction: Direction = facing_direction
+        self._last_graphic_state: GraphicState = graphic_state
+        self.sprite_sheet = self.engine.assets.get_sprite_data(sprite_name)
+
+        if self.name:
+            data = self._get_data(
+                self._last_graphic_state, self._last_direction
+            )
+            self._frame_index: int = 0
+            self._timer: float = data["duration"][0]
+            self._ox = data["ox"][0]
+            self._oy = data["oy"][0]
+            self._image_name = data["image"][0]
+            self.width = data["width"][0]
+            self.height = data["height"][0]
+        else:
+            self.width = self.engine.rtc.tile_width
+            self.height = self.engine.rtc.tile_height
+        # # TODO: Handle ""
+        # if tileset_name and image_name and self._sprite_name:
+        #     LOG.info(
+        #         {
+        #             "operation": "load sprite",
+        #             "tileset": tileset_name,
+        #             "image": image_name,
+        #             "sprite": self._sprite_name,
+        #         }
+        #     )
+        #     tileset = self.engine.assets.get_tileset(tileset_name)
+
+        #     self.width = tileset.tile_width
+        #     self.height = tileset.tile_height
+
+        #     self._sprites: Dict[GraphicState, Dict[Direction, Dict[str, Any]]] = (
+        #         self._load_sprites_from_tileset(tileset, self._sprite_name)
+        #     )
+
+        # else:
+        #     LOG.debug(
+        #         "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 = ""
+
+    def update(
+        self,
+        elapsed_time: float,
+        direction: Direction = Direction.SOUTH,
+        graphic_state: GraphicState = GraphicState.STANDING,
+    ):
+        if not self.name:
+            return
+
+        data = self._get_data(graphic_state, direction)
+
+        if (
+            direction == self._last_direction
+            and graphic_state == self._last_graphic_state
+        ):
+            # No changes, normal case
+            self._timer -= elapsed_time
+            if self._timer <= 0.0:
+                self._frame_index = (self._frame_index + 1) % len(
+                    data["duration"]
+                )
+                self._timer += data["duration"][self._frame_index]
+                self._ox = data["ox"][self._frame_index]
+                self._oy = data["oy"][self._frame_index]
+                self._image_name = data["image"][self._frame_index]
+                self.width = data["width"][self._frame_index]
+                self.height = data["height"][self._frame_index]
+        else:
+            self._frame_index = 0
+            # Something changed
+            # if graphic_state != self._last_graphic_state:
+            # State changed
+
+            self._timer = data["duration"][0]
+            self._ox = data["ox"][0]
+            self._oy = data["oy"][0]
+            self._image_name = data["image"][0]
+            self.width = data["width"][0]
+            self.height = data["height"][0]
+
+        self._last_direction = direction
+        self._last_graphic_state = graphic_state
+
+    def draw_self(
+        self,
+        px: float,
+        py: float,
+        camera_name: str = "display",
+        absolute_position: bool = False,
+        draw_to_ui: bool = False,
+    ):
+        if not self.name:
+            return
+
+        if not absolute_position:
+            px *= self.engine.rtc.tile_width
+            py *= self.engine.rtc.tile_height
+        px, py = math.floor(px), math.floor(py)
+
+        self.engine.backend.draw_partial_sprite(
+            px,
+            py,
+            self._image_name,
+            self._ox * self.width,
+            self._oy * self.height,
+            self.width,
+            self.height,
+            camera_name,
+            draw_to_ui=draw_to_ui,
+        )
+
+    def _load_sprites_from_tileset(self, tileset, sprite_name):
+        if sprite_name in AnimatedSprite.sprite_sets:
+            # Caching
+            return AnimatedSprite.sprite_sets[sprite_name]
+
+        sprites = {}
+
+        for tile in tileset.tiles:
+            if tile.sprite_name != sprite_name:
+                continue
+
+            if tile.animated:
+                data = {"duration": [], "ox": [], "oy": []}
+                for frame in tile._frames:
+                    data["duration"].append(frame.duration)
+                    data["ox"].append(frame.frame_id % tileset.columns)
+                    data["oy"].append(frame.frame_id // tileset.columns)
+            else:
+                data = {
+                    "duration": [1000],
+                    "ox": [tile.tile_id % tileset.columns],
+                    "oy": [tile.tile_id // tileset.columns],
+                }
+
+            sprites.setdefault(tile.graphic_state, {})
+            sprites[tile.graphic_state][tile.facing_direction] = data
+            LOG.debug(
+                {
+                    "operation": "add frames",
+                    "image": self.name,
+                    "sprite": sprite_name,
+                    "graphic_state": tile.graphic_state.name,
+                    "direction": tile.facing_direction.name,
+                    "frame_data": data,
+                }
+            )
+
+        AnimatedSprite.sprite_sets[sprite_name] = sprites
+        return sprites
+        # for tile in tileset.tiles
+        # Check non-animated tiles if necessary
+
+    def reset(self):
+        self._frame_index = 0
+        self._timer = 0.0
+
+    def _get_data(self, graphic_state, direction):
+        if graphic_state == GraphicState.DEFEATED:
+            graphic_state = graphic_state.DEAD
+
+        data = self.sprite_sheet.get(
+            graphic_state, self.sprite_sheet.get(GraphicState.STANDING, {})
+        )
+        data = data.get(direction, data.get(Direction.SOUTH, {}))
+        if not data:
+            try:
+                LOG.debug(
+                    "Animation of sprite %s is empty for %s, %s ",
+                    self.name,
+                    graphic_state.name,
+                    direction.name,
+                )
+            except Exception:
+                # print(graphic_state, direction)
+                LOG.exception(graphic_state, direction)
+                raise
+            data = {
+                "ox": [0],
+                "oy": [0],
+                "duration": [1.0],
+                "image": [""],
+                "width": [0],
+                "height": [0],
+            }
+        return data

mima/objects/attribute_effect.py

@@ -0,0 +1,26 @@
+from .attributes import Attributes
+
+
+class Effect(Attributes):
+    def __init__(self):
+        super().__init__()
+
+        self.effect_id: str = ""
+        self.duration: float = 0.0
+        self.redundant: bool = False
+        self.health_cost: float = 0.0
+        self.magic_cost: float = 0.0
+        self.stamina_cost: float = 0.0
+
+    def update(self, elapsed_time: float):
+        self.duration -= self.elapsed_time
+        if self.duration < 0.0:
+            self.redundant = True
+
+    @staticmethod
+    def from_dict(data):
+        attr = Effect()
+        for key, val in data.items():
+            setattr(attr, key, val)
+
+        return attr

mima/objects/attributes.py

@@ -0,0 +1,126 @@
+from typing import Dict
+
+from ..types.damage import Damage
+from ..util.constants import ATTRIBUTE_TIMER
+
+
+class Attributes:
+    """A class holding all the attributes of an object.
+
+    Attributes
+    ----------
+
+    health: float
+        The current health of the object.
+    health_max: float
+        The maximum health of the object.
+    speed: float
+        The current speed value of the object. If different run speeds
+        are not relevant for the object, this is the only value to
+        consider. Otherwise, this value might be changed by objects
+        itself to reflect different states.
+    speed_mod: float
+        A modification of the speed used by the game engine, e.g., when
+        walking in shallow water
+    walk_speed: float
+        The speed value when the objects moves slow, e.g., when it is
+        walking.
+    run_speed: float
+        The speed value when the object moves fast, e.g., when it is
+        running.
+    acceleration: float
+        The acceleration of the object when it starts to move. Ranges
+        between 0 and 1
+    friction: float
+        The friction of the object when it stops moving. Ranges between
+        0 and 1.
+
+    """
+
+    def __init__(self):
+        self.health: float = 10.0
+        self.health_max: float = 10.0
+        self.health_per_second: float = 0.0
+        self.magic: float = 10.0
+        self.magic_max: float = 10.0
+        self.magic_per_second: float = 0.1
+        self.stamina: float = 10.0
+        self.stamina_max: float = 10.0
+        self.stamina_per_second: float = 2.0
+        self.speed: float = 1.0
+        self.speed_mod: float = 1.0
+        self.walk_speed: float = 1.0
+        self.run_speed: float = 1.0
+        # self.current_speed: float = 0.0  # Acceleration and Friction
+        self.knock_speed: float = 5.0
+        self.acceleration: float = 15.0
+        self.friction: float = 15.0
+
+        self.timer: float = 0.25
+        self.gravity_vz: float = 40.0
+        self.light_radius: float = 32
+
+        self.coins: int = 0
+        self.coins_max: int = 100_000
+        self.keys: int = 0
+        self.keys_max: int = 100_000
+        self.bombs: int = 0
+        self.bombs_max: int = 5
+        self.arrows: int = 0
+        self.arrows_max: int = 15
+
+        self.body_damage: int = 0
+
+        self.strength: int = 0
+        self.dexterity: int = 0
+        self.intelligence: int = 0
+        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}
+
+    def update(self, elapsed_time: float):
+        self.timer -= elapsed_time
+        if self.timer <= 0.0:
+            self.timer += ATTRIBUTE_TIMER
+
+            self.health = min(
+                self.health + self.health_per_second * ATTRIBUTE_TIMER,
+                self.health_max,
+            )
+            self.magic = min(
+                self.magic + self.magic_per_second * ATTRIBUTE_TIMER,
+                self.magic_max,
+            )
+            self.stamina = min(
+                self.stamina + self.stamina_per_second * ATTRIBUTE_TIMER,
+                self.stamina_max,
+            )
+
+    @staticmethod
+    def from_dict(data):
+        attr = Attributes()
+
+        for key, val in data.items():
+            if "defense" in key:
+                def_key = key.split("_", 1)[1]
+                attr.defense[def_key] = val
+            setattr(attr, key, val)
+
+        return attr
+
+    @property
+    def health_percent(self):
+        return self.health / self.health_max
+
+    @property
+    def magic_percent(self):
+        return self.magic / self.magic_max
+
+    @property
+    def stamina_percent(self):
+        return self.stamina / self.stamina_max