mima-engine 0.1.0__py3-none-any.whl

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,123 @@
+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.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

mima/objects/creature.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, 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.terrain import Terrain
+from ..types.weapon_slot import WeaponSlot
+
+# from ..types.weapon_slot import WeaponSlot
+from ..util.colors import BLACK
+from ..util.constants import DEFAULT_KNOCK_SPEED
+from .animated_sprite import AnimatedSprite
+from .dynamic import Dynamic
+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
+
+
+class Creature(Dynamic):
+    def __init__(
+        self,
+        name: str,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: str,
+        px: float,
+        py: float,
+        dyn_id: int = -1,
+    ):
+        super().__init__(name, px, py, dyn_id)
+
+        self.sprite = AnimatedSprite(tileset_name, image_name, sprite_name)
+        self.type = ObjectType.CREATURE
+        self.knock_speed: float = DEFAULT_KNOCK_SPEED
+
+        # self.sprite.name = sprite_name
+        # self.sprite.num_frames = 2
+        self.attackable = True
+
+        self._knock_vx: float = 0.0
+        self._knock_vy: float = 0.0
+        self.real_vx: float = 0.0
+        self.real_vy: float = 0.0
+        self.last_vx: float = 0.0
+        self.last_vy: float = 0.0
+        self._attack_timer: float = 0.0
+        self._invincible_timer: float = 0.0
+        self._knock_timer: float = 0.0
+        self._state_timer: float = 0.0
+
+        self.invincible: bool = False
+        # self.use_acceleration: bool = True
+        # self.use_friction: bool = True
+
+        self.projectiles: List[Projectile] = []
+        self.weapons: Dict[WeaponSlot, Optional[Weapon]] = {
+            WeaponSlot.FIRST_HAND: None,
+            WeaponSlot.SECOND_HAND: None,
+        }
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+
+        if not self.visible:
+            self.vx = self.vy = 0.0
+            return
+
+        if self._knock_timer > 0.0:  # Handle knocking
+            self._knock_timer -= elapsed_time
+            self._invincible_timer -= elapsed_time
+            self.vx, self.vy = self._knock_vx, self._knock_vy
+            self.speed = self.knock_speed
+            self.change_graphic_state(GraphicState.DAMAGED)
+
+            if self._knock_timer <= 0.0:  # Knocking is over
+                self._state_timer = 0.0
+                self.controllable = True
+                self.solid_vs_dyn = True
+                self.sprite.reset()
+
+        else:  # Usual update
+            if self._invincible_timer > 0.0:
+                self._invincible_timer -= elapsed_time
+            if self._invincible_timer <= 0.0:
+                self.invincible = False
+                self._invincible_timer = 0.0
+
+            if self._attack_timer > 0.0:
+                self._attack_timer -= elapsed_time
+                self.change_graphic_state(GraphicState.ATTACKING)
+
+            if self._attack_timer <= 0:
+                self._attack_timer = 0.0
+                if abs(self.vx) > 0 or abs(self.vy) > 0:
+                    self.change_graphic_state(GraphicState.WALKING)
+                else:
+                    self.change_graphic_state(GraphicState.STANDING)
+
+            if self.attributes.health <= 0:
+                self.change_graphic_state(GraphicState.DEAD)
+
+            if self.vx < -0.01:
+                self.facing_direction = Direction.WEST
+            if self.vx > 0.01:
+                self.facing_direction = Direction.EAST
+            if self.vy < -0.01:
+                self.facing_direction = Direction.NORTH
+            if self.vy > 0.01:
+                self.facing_direction = Direction.SOUTH
+
+            self.speed = self.attributes.speed
+
+            if self.can_act():
+                self.behavior(elapsed_time, target)
+
+        self.sprite.update(
+            elapsed_time, self.facing_direction, self.graphic_state
+        )
+
+        self._handle_terrain(elapsed_time)
+
+        if self.graphic_state == GraphicState.DEAD:
+            self.attackable = False
+            self.vx = self.vy = 0
+            if self.despawn_timer is None:
+                self.despawn_timer = self.despawn_duration
+                self.engine.play_sound("enemy_killed")
+            else:
+                self.despawn_timer -= elapsed_time
+
+            if self.despawn_timer <= 0.0:
+                self.kill()
+        else:
+            eff2r = []
+            for eff in self.attribute_effects:
+                if (
+                    self.attributes.health < eff.health_cost
+                    or self.attributes.magic < eff.magic_cost
+                    or self.attributes.stamina < eff.stamina_cost
+                    # and self.attributes.arrows >= weapon.arrow_cost
+                    # and self.attributes.bombs >= weapon.bomb_cost
+                ):
+                    eff.redundant = True
+                    self.attributes.health_per_second += eff.health_cost
+                    self.attributes.magic_per_second += eff.magic_cost
+                    self.attributes.stamina_per_second += eff.stamina_cost
+                    eff2r.append(eff)
+            for e in eff2r:
+                self.attribute_effects.remove(e)
+
+            self.attributes.update(elapsed_time)
+
+        if self._gs_lock_condition == Until.NEXT_UPDATE:
+            self.graphic_state_locked = False
+
+    def draw_self(self, ox: float, oy: float):
+        if (
+            self.sprite.name is None
+            or self.sprite.name == ""
+            or not self.visible
+        ):
+            return
+
+        px = self.px - ox + self.extra_ox
+        py = self.py - oy + self.extra_oy
+
+        if self.pz != 0:
+            self.engine.backend.fill_circle(
+                px + 0.5 * self.sprite.width,
+                py + 0.7 * self.sprite.height,
+                0.3125 * self.sprite.width,
+                BLACK,
+            )
+
+        self.sprite.draw_self(px, py - self.pz)
+        # for effect in self.effects:
+        #     effect.draw_self(px, py - self.pz)
+
+    def behavior(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        # No default behavior
+        pass
+
+    def on_interaction(self, target=None, nature=Nature.WALK):
+        if nature == Nature.SIGNAL:
+            self.solid_vs_dyn = False
+            self.visible = False
+            return True
+
+        elif nature == Nature.NO_SIGNAL:
+            self.visible = True
+            self.solid_vs_dyn = True
+            return True
+        return False
+
+    def knock_back(self, vx: float, vy: float, dist: float):
+        self._knock_vx = vx
+        self._knock_vy = vy
+        self._knock_timer = dist
+        self.invincible_timer = dist + 0.2
+        # self.solid_vs_dyn = False
+        self.controllable = False
+        self.invincible = True
+        self.sprite.reset()
+        self.cancel_attack()
+
+    def can_act(self):
+        actable_states = [
+            GraphicState.STANDING,
+            GraphicState.WALKING,
+            GraphicState.CELEBRATING,
+            # GraphicState.DAMAGED,
+            GraphicState.PUSHING,
+        ]
+        if self.graphic_state in actable_states:
+            return True
+
+        return False
+
+    def perform_attack(self, slot: WeaponSlot) -> bool:
+        weapon = self.weapons.get(slot, None)
+
+        if weapon is None or not self.can_attack:
+            # print(f"Cannot attack. Weapon={weapon}")
+            return False
+
+        # Clean up all previous projectiles
+        self.cancel_attack()
+
+        if (
+            self.attributes.health >= weapon.health_cost
+            and self.attributes.magic >= weapon.magic_cost
+            and self.attributes.stamina >= weapon.stamina_cost
+            and self.attributes.arrows >= weapon.arrow_cost
+            and self.attributes.bombs >= weapon.bomb_cost
+        ):
+            self.attributes.health -= weapon.health_cost
+            self.attributes.magic -= weapon.magic_cost
+            self.attributes.stamina -= weapon.stamina_cost
+            self.attributes.arrows -= weapon.arrow_cost
+            self.attributes.bombs -= weapon.bomb_cost
+        else:
+            return False
+
+        if weapon.on_use(self):
+            self.vx = self.vy = 0.0
+            self._attack_timer = weapon.swing_timer
+            return True
+
+        return False
+
+    def cancel_attack(self):
+        # if self.projectiles:
+        for projectile in self.projectiles:
+            if projectile is not None:
+                projectile.spawn_on_death = []
+                projectile.kill()
+
+        self.projectiles = []
+
+    def on_death(self):
+        if self.spawn_on_death:
+            for do in self.spawn_on_death:
+                if do.redundant:
+                    continue
+                if do.type == ObjectType.PROJECTILE:
+                    if do.inherit_pos:
+                        do.px = self.px
+                        do.py = self.py
+                    self.engine.scene.add_projectile(do)
+                else:
+                    self.engine.scene.add_dynamic(do)
+
+        self.spawn_on_death = []
+
+    def _handle_terrain(self, elapsed_time: float):
+        e2rm = []
+        for effect in self.effects:
+            if isinstance(effect, WalkingOnGrass):
+                if self.walking_on == Terrain.DEFAULT:
+                    e2rm.append(effect)
+
+        for effect in e2rm:
+            self.effects.remove(effect)
+
+        if self.walking_on in [Terrain.GRASS, Terrain.SHALLOW_WATER]:
+            self.attributes.speed_mod = 0.7
+            effect_active = False
+            for effect in self.effects:
+                if isinstance(effect, (WalkingOnGrass, WalkingOnWater)):
+                    effect_active = True
+                    effect.renew = True
+                    break
+
+            if not effect_active:
+                if self.walking_on == Terrain.GRASS:
+                    eff = WalkingOnGrass(self)
+                else:
+                    eff = WalkingOnWater(self)
+                self.effects.append(eff)
+                self.engine.scene.add_effect(eff)
+        else:
+            self.attributes.speed_mod = 1.0
+
+    def equip_weapon(self, slot, weapon):
+        if self.weapons[slot] == weapon:
+            # Weapon already equipped; unequip
+            self.weapons[slot] = None
+            weapon.on_unequip(self)
+            return
+
+        for s, w in self.weapons.items():
+            if slot != s and weapon == w:
+                # Weapon equipped in a different slot; change
+                self.weapons[slot] = weapon
+                self.weapons[s] = None
+                return
+
+        if self.weapons[slot] is not None:
+            # Other weapon equipped; unequip that
+            self.weapons[slot].on_unequip(self)
+
+        self.weapons[slot] = weapon
+        weapon.on_equip(self)
+
+    def unequip_weapon(self, slot):
+        if self.weapons[slot] is not None:
+            self.weapons[slot].on_unequip(self)

mima/objects/dynamic.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Optional
+
+from ..types.alignment import Alignment
+from ..types.damage import Damage
+from ..types.direction import Direction
+from ..types.graphic_state import GraphicState, Until
+from ..types.nature import Nature
+from ..types.object import ObjectType
+from ..types.terrain import Terrain
+from .attributes import Attributes
+from .attribute_effect import Effect
+from .sprite import Sprite
+
+if TYPE_CHECKING:
+    from ..engine import MimaEngine
+    from .projectile import Projectile
+
+
+class Dynamic:
+    engine: MimaEngine
+
+    def __init__(
+        self,
+        name: str = "Unnamed Dynamic",
+        px: float = 0.0,
+        py: float = 0.0,
+        dyn_id=-1,
+    ):
+        self.name: str = name
+        self.dyn_id: int = dyn_id  # ID given by Tiled
+        self.layer: int = 1
+
+        self.px: float = px
+        self.py: float = py
+        self.pz: float = 0.0
+        self.vx: float = 0.0
+        self.vy: float = 0.0
+        self.vz: float = 0.0
+        self.real_vx: float = 0.0
+        self.real_vy: float = 0.0
+        self.hitbox_px: float = 0.1
+        self.hitbox_py: float = 0.1
+        self.hitbox_width: float = 0.8
+        self.hitbox_height: float = 0.8
+        self.attribute_timer: float = 0.25
+        self.despawn_timer: float = 0.5
+        self.despawn_duration: float = 0.2
+        self.timer: float = 0.0
+        self.speed: float = 1.0
+
+        self.solid_vs_map: bool = True
+        self.solid_vs_dyn: bool = True
+        # self.is_player: bool = False
+        # self.is_projectile: bool = False
+        self.redundant: bool = False
+        self.persistent: bool = False
+        self.attackable: bool = False
+        self.controllable: bool = True
+        self.state_changed: bool = False
+        self.visible: bool = True
+        self.gravity: bool = True
+        self.graphic_state_locked: bool = False
+        self.use_acceleration: bool = False
+        self.use_friction: bool = False
+
+        self.alignment: Alignment = Alignment.GOOD
+        self.walking_on: Terrain = Terrain.DEFAULT
+        self.attributes: Attributes = Attributes()
+        self.facing_direction: Direction = Direction.SOUTH
+        self.graphic_state: GraphicState = GraphicState.STANDING
+        self._gs_lock_condition: Until = Until.UNLOCK
+        self.type: ObjectType = ObjectType.UNDEFINED
+        self.spawn_on_death: List[Dynamic] = []
+        self.childs: List[Dynamic] = []
+        self.effects: List[Projectile] = []
+        self.attribute_effects: List[Effect] = []
+
+        self.extra_ox: float = 0.0
+        self.extra_oy: float = 0.0
+
+        self.can_attack: bool = True
+        self.can_lift: bool = False
+        self.can_push: bool = False
+
+        self.sprite: Sprite = Sprite()
+
+        # Performance flags
+        self.update_skippable: bool = False
+        """Update may be skipped if object is offscreen."""
+        self.offscreen_collision_skippable: bool = True
+        """Collision checks may be skipped if object is offscreen."""
+        self.onscreen_collision_skippable: bool = False
+        """Collision checks may be skipped if object is onscreen."""
+        self.draw_skippable: bool = True
+        """Drawing the unit may be skipped if object is offscreen."""
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic]):
+        """Update this dynamic."""
+        pass
+
+    def draw_self(self, ox: float, oy: float):
+        """Draw self to screen"""
+        pass
+
+    def on_interaction(
+        self, target: Dynamic = None, nature: Nature = Nature.WALK
+    ) -> bool:
+        """Handle interaction with other dynamic objects."""
+        return False
+
+    def on_death(self) -> bool:
+        return False
+
+    def kill(self):
+        self.redundant = True
+
+    def change_graphic_state(self, new_state: GraphicState) -> bool:
+        if self.graphic_state_locked or new_state == self.graphic_state:
+            return False
+
+        self.graphic_state = new_state
+        self.sprite.update(0.0, self.facing_direction, self.graphic_state)
+
+        return True
+
+    def lock_graphic_state(
+        self,
+        new_state: GraphicState = GraphicState.STANDING,
+        until: Until = Until.UNLOCK,
+    ):
+        self.change_graphic_state(new_state)
+        self.graphic_state_locked = True
+        self._gs_lock_condition = until
+
+    def unlock_graphic_state(self):
+        self.graphic_state_locked = False
+        self.change_graphic_state(GraphicState.STANDING)
+
+    def get_defense_value(self, dtype: Damage) -> int:
+        return self.attributes.defense[dtype]
+
+    def is_py_lower(self, other: Dynamic) -> bool:
+        return self.py < other.py
+
+    def get_alignment(self) -> Alignment:
+        return self.alignment
+
+    def add_effect(self, eff: Effect):
+        self.attribute_effects.append(eff)
+
+    def remove_effect(self, eff: Union[str, Effect]):
+        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]
+
+        self.attribute_effects.remove(eff)
+
+    def has_effect(self, eff: Union[str, Effect]):
+        if isinstance(eff, str):
+            for e in self.attribute_effects:
+                if e.effect_id == eff:
+                    return True
+            return False
+        else:
+            if eff in self.attribute_effects:
+                return True
+            else:
+                return False
+
+    def light_radius(self):
+        rad = self.attributes.light_radius
+
+        for eff in self.attribute_effects:
+            rad += eff.light_radius
+
+        return rad

mima/objects/effects/colorize_screen.py

@@ -0,0 +1,36 @@
+from ...types.alignment import Alignment
+from ...util.colors import Color, BLACK
+from ...util.constants import HEIGHT, WIDTH
+from ..dynamic import Dynamic
+from ..projectile import Projectile
+
+
+class ColorizeScreen(Projectile):
+    def __init__(
+        self,
+        color: Color = BLACK,
+        alpha=BLACK.alpha,
+        duration: float = -1.0,
+        to_filter: bool = False,
+    ):
+        super().__init__(0, 0, 0, 0, duration, Alignment.GOOD)
+        self.layer = 1
+        self.solid_vs_map = False
+        self.color = color
+        self.alpha = alpha
+        self.vanishs_after_time: bool = duration > 0
+        self.to_filter = to_filter
+
+    def update(self, elapsed_time: float, target: Dynamic = None):
+        if self.vanishs_after_time:
+            self.duration -= elapsed_time
+            if self.duration <= 0.0:
+                self.kill()
+
+        # self.sprite.update(elapsed_time, self.facing_direction, self.graphic_state)
+
+    def draw_self(self, ox: float, oy: float):
+        color = Color(self.color.red, self.color.green, self.color.blue, self.alpha)
+        self.engine.backend.fill_rect(
+            self.px, self.py, self.engine.backend.render_width, self.engine.backend.render_height, color, draw_to_filter=self.to_filter
+        )