mima-engine 0.4.0__py3-none-any.whl

mima/backend/touch_control_scheme_a.py

@@ -0,0 +1,126 @@
+import time
+
+import pygame
+
+from ..types.keys import Key as K
+from ..util.constants import DOUBLE_TAP_SPEED
+from ..util.input_defaults import BUTTONS, DEFAULT_TOUCHSCREEN_MAP
+
+
+class TouchControlSchemeA:
+
+    def __init__(self):
+
+        self._left_finger_tap_pos = 0.0
+        self._right_finger_tap_pos = 0.0
+
+        self._last_left_tap = 0.0
+        self._last_right_tap = 0.0
+
+    def handle_touch(self, event, width=1.0, height=1.0):
+        set_keys = []
+        unset_keys = []
+
+        tap_pos = pygame.Vector2(event.x * width, event.y * height)
+
+        if event.type == pygame.FINGERDOWN:
+            tap_time = time.time()
+            for key, area in DEFAULT_TOUCHSCREEN_MAP.items():
+
+                if (
+                    area[0][0] <= event.x < area[1][0]
+                    and area[0][1] <= event.y < area[1][1]
+                ):
+                    if key == K.P1_UP:
+                        self._left_finger_tap_pos = tap_pos
+                        if tap_time - self._last_left_tap < DOUBLE_TAP_SPEED:
+                            # print("Left Double Tap")
+                            set_keys.append(K.P1_SELECT)
+                        self._last_left_tap = tap_time
+                    elif key == K.P1_L:
+                        set_keys.append(K.P1_L)
+                    else:
+                        set_keys.append(key)
+                        self._right_finger_tap_pos = tap_pos
+                        self._last_right_tap = tap_time
+
+        if event.type == pygame.FINGERUP:
+            # release = time.time()
+            # finger_dist = (finger_pos - self._left_finger_tap_pos).length()
+
+            if event.x < 0.5:
+                # print(f"Left Finger Up: {finger_pos}")
+                # if (
+                #     SINGLE_TAP_MIN
+                #     < release - self._last_left_tap
+                #     < SINGLE_TAP_MAX
+                # ) and finger_dist < 2.5:
+                #     print("Left Single Tap")
+                #     # set_keys.append(K.START)
+
+                unset_keys.append(K.P1_SELECT)
+                unset_keys.append(K.P1_RIGHT)
+                unset_keys.append(K.P1_LEFT)
+                unset_keys.append(K.P1_UP)
+                unset_keys.append(K.P1_DOWN)
+                unset_keys.append(K.P1_L)
+                # print(
+                #     f"Left Finger moved {finger_dist} "
+                #     f"({release - self._last_left_tap} s)"
+                # )
+            else:
+                unset_keys.append(K.P1_START)
+                unset_keys.append(K.P1_A)
+                unset_keys.append(K.P1_B)
+                unset_keys.append(K.P1_Y)
+                unset_keys.append(K.P1_X)
+                unset_keys.append(K.P1_R)
+
+        if event.type == pygame.FINGERMOTION:
+            if event.x < 0.5:
+                vd = tap_pos - self._left_finger_tap_pos
+                unset_keys.append(K.P1_RIGHT)
+                unset_keys.append(K.P1_LEFT)
+                unset_keys.append(K.P1_UP)
+                unset_keys.append(K.P1_DOWN)
+                if abs(vd.x) > 2 * abs(vd.y):
+                    # Horizontal
+                    if vd.x > 5.0:
+                        set_keys.append(K.P1_RIGHT)
+                        unset_keys.append(K.P1_LEFT)
+                        unset_keys.append(K.P1_UP)
+                        unset_keys.append(K.P1_DOWN)
+                    elif vd.x < -5.0:
+                        set_keys.append(K.P1_LEFT)
+                        unset_keys.append(K.P1_RIGHT)
+                        unset_keys.append(K.P1_UP)
+                        unset_keys.append(K.P1_DOWN)
+                elif abs(vd.x) * 2 < abs(vd.y):
+                    # Vertical
+                    if vd.y > 5.0:
+                        unset_keys.append(K.P1_RIGHT)
+                        unset_keys.append(K.P1_LEFT)
+                        unset_keys.append(K.P1_UP)
+                        set_keys.append(K.P1_DOWN)
+                    elif vd.y < -5.0:
+                        unset_keys.append(K.P1_LEFT)
+                        unset_keys.append(K.P1_RIGHT)
+                        set_keys.append(K.P1_UP)
+                        unset_keys.append(K.P1_DOWN)
+                elif abs(vd.x) * 1.05 > abs(vd.y) or abs(vd.x) < 1.05 * abs(
+                    vd.y
+                ):
+                    if vd.x < 0:
+                        set_keys.append(K.P1_LEFT)
+                    elif vd.x > 0:
+                        set_keys.append(K.P1_RIGHT)
+                    if vd.y < 0:
+                        set_keys.append(K.P1_UP)
+                    elif vd.y > 0:
+                        set_keys.append(K.P1_DOWN)
+                self.vd = vd
+
+        return set_keys, unset_keys
+
+    def get_touch_state(self):
+        return {}

mima/backend/touch_control_scheme_b.py

@@ -0,0 +1,132 @@
+import time
+
+import pygame
+
+from ..types.keys import Key as K
+from ..util.constants import DOUBLE_TAP_SPEED
+from ..util.input_defaults import ALT_TOUCHSCREEN_MAP, BUTTONS
+
+
+class TouchControlSchemeB:
+
+    def __init__(self):
+
+        self.move_start_pos = pygame.Vector2()
+        self.move_pos = pygame.Vector2()
+        self.move_sy = 0.0
+        self.move_px = 0.0
+        self.move_py = 0.0
+        self._left_finger_tap_pos = 0.0
+        self._right_finger_tap_pos = 0.0
+
+        self._last_left_tap = 0.0
+        self._last_right_tap = 0.0
+        self._keys_active = {k: False for k in K}
+        self._state = {}
+        for key, conf in ALT_TOUCHSCREEN_MAP.items():
+            px, py = conf["pos"]
+            w, h = conf["size"]
+            self._state[key] = {
+                "rpx": px,
+                "rpy": py,
+                "rwidth": w,
+                "rheight": h,
+                "active": False,
+            }
+
+    def handle_touch(self, event, width=1.0, height=1.0):
+        set_keys = []
+        unset_keys = []
+
+        tap_pos = pygame.Vector2(event.x * width, event.y * height)
+        keys_active = {k: False for k in K}
+        # print(f"{event.x:.2f}, {event.y:.2f}", end="")
+        for key, conf in ALT_TOUCHSCREEN_MAP.items():
+            px, py = conf["pos"]
+            w, h = conf["size"]
+            area = [[px, py], [px + w, py + h]]
+
+            if (
+                area[0][0] <= event.x < area[1][0]
+                and area[0][1] <= event.y < area[1][1]
+            ):
+                if key == K.P1_UP:
+                    if event.type == pygame.FINGERDOWN:
+                        self.move_start_pos = pygame.Vector2(tap_pos)
+                        self.move_pos = pygame.Vector2(tap_pos)
+                        self._state[key]["rsx"] = event.x
+                        self._state[key]["rsy"] = event.y
+                        self._state[key]["rpx"] = event.x
+                        self._state[key]["rpy"] = event.y
+                    elif event.type == pygame.FINGERMOTION:
+                        self.move_pos = tap_pos
+                        self._state[key]["rpx"] = event.x
+                        self._state[key]["rpy"] = event.y
+
+                        vd = self.move_pos - self.move_start_pos
+                        if abs(vd.x) > 2 * abs(vd.y):
+                            # Horizontal
+                            if vd.x > 5.0:
+                                keys_active[K.P1_RIGHT] = True
+                                # print("..>", end="")
+                            elif vd.x < -5.0:
+                                keys_active[K.P1_LEFT] = True
+                                # print("..<", end="")
+                        elif abs(vd.x) * 2 < abs(vd.y):
+                            # Vertical
+                            if vd.y > 5.0:
+                                keys_active[K.P1_DOWN] = True
+                                # print("..v", end="")
+                            elif vd.y < -5.0:
+                                keys_active[K.P1_UP] = True
+                                # print("..^", end="")
+                        elif abs(vd.x) * 1.05 > abs(vd.y) or abs(
+                            vd.x
+                        ) < 1.05 * abs(vd.y):
+                            # Diagonal
+                            if vd.x < 0:
+                                keys_active[K.P1_LEFT] = True
+                                # print("..<", end="")
+                            elif vd.x > 0:
+                                keys_active[K.P1_RIGHT] = True
+                                # print("..>", end="")
+                            if vd.y < 0:
+                                keys_active[K.P1_UP] = True
+                                # print("..^", end="")
+                            elif vd.y > 0:
+                                keys_active[K.P1_DOWN] = True
+                                # print("..v", end="")
+                    # elif event.type == pygame.FINGERUP:
+                    #     unset_keys.append(K.P1_RIGHT)
+                    #     unset_keys.append(K.P1_LEFT)
+                    #     unset_keys.append(K.P1_UP)
+                    #     unset_keys.append(K.P1_DOWN)
+                else:
+                    if event.type == pygame.FINGERDOWN:
+                        keys_active[key] = True
+                        # print(f"..{key.name}", end="")
+                    if event.type == pygame.FINGERMOTION:
+                        keys_active[key] = True
+                        # print(f"..{key.name}", end="")
+        # print()
+        for k, val in keys_active.items():
+            if val:
+                set_keys.append(k)
+                # self._state.setdefault(k, {})["active"] = True
+                if k in self._state:
+                    self._state[k]["active"] = True
+                if k in [K.P1_LEFT, K.P1_RIGHT, K.P1_DOWN]:
+                    self._state[K.P1_UP]["active"] = True
+            else:
+                unset_keys.append(k)
+                if k in self._state:
+                    self._state[k]["active"] = False
+        return set_keys, unset_keys
+
+    def get_touch_state(self):
+        state = {}
+        for key, conf in self._state.items():
+            nkey = K(key.value - 12)
+            state[nkey] = conf
+
+        return state

mima/core/collision.py

@@ -0,0 +1,325 @@
+from __future__ import annotations
+
+import math
+from itertools import product
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Tuple
+
+from ..maps.tilemap import Tilemap
+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 ..objects.dynamic import Dynamic
+    from ..states.quest import Quest
+
+    # from .view.view import View
+
+
+def check_object_to_map_collision(
+    elapsed_time: float,
+    obj: Dynamic,
+    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
+    bottom = top + obj.hitbox_height
+
+    collided_with_map = False
+    if obj.solid_vs_map:
+        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
+            # where to push the object
+            if new_px == obj.px:
+                decimal_dif = new_px - int(new_px)
+                if abs(decimal_dif) > 0.5:
+                    new_px += 0.0001
+                else:
+                    new_px -= 0.0001
+
+            # Did the object move from right to left?
+            if new_px < obj.px:
+                new_px += int(left) + 1.0 - left
+            else:
+                new_px -= right - int(right) + 0.001
+
+            obj.vx = 0
+            collided_with_map = True
+            if (
+                obj.facing_direction in [Direction.WEST, Direction.EAST]
+                and obj.can_push
+            ):
+                obj.lock_graphic_state(GraphicState.PUSHING, Until.NEXT_UPDATE)
+
+        left = new_px + obj.hitbox_px
+        right = left + obj.hitbox_width
+        top = new_py + obj.hitbox_py
+        bottom = top + obj.hitbox_height
+
+        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)
+                if abs(decimal_dif) > 0.5:
+                    new_py += 0.0001
+                else:
+                    new_py -= 0.0001
+
+            if new_py < obj.py:
+                new_py += int(top) + 1.0 - top
+            else:
+                new_py -= bottom - int(bottom) + 0.001
+
+            obj.vy = 0
+            collided_with_map = True
+            if (
+                obj.facing_direction in [Direction.NORTH, Direction.SOUTH]
+                and obj.can_push
+            ):
+                obj.lock_graphic_state(GraphicState.PUSHING, Until.NEXT_UPDATE)
+
+        if obj.type == ObjectType.PROJECTILE and collided_with_map:
+            obj.kill()
+
+    return new_px, new_py
+
+
+def collision_with_map(
+    tilemap: Tilemap,
+    left: float,
+    right: float,
+    top: float,
+    bottom: float,
+    layer: int = 0,
+    collision: TileCollision = TileCollision.TOP,
+) -> bool:
+    if tilemap.is_solid(left, top, layer, collision):
+        return True
+    if tilemap.is_solid(left, bottom, layer, collision):
+        return True
+    if tilemap.is_solid(right, top, layer, collision):
+        return True
+    if tilemap.is_solid(right, bottom, layer, collision):
+        return True
+
+    return False
+
+
+def check_object_to_object_collision(
+    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]:
+    quests = quests if quests is not None else []
+    deal_damage = deal_damage if deal_damage is not None else lambda x, y: None
+
+    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:
+            _check_player_with_non_solid(obj, other, pxys, quests)
+
+        else:
+            _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,
+    top1: float,
+    bottom1: float,
+    left2: float,
+    right2: float,
+    top2: float,
+    bottom2: float,
+) -> bool:
+    if left1 < right2 and right1 > left2 and top1 < bottom2 and bottom1 > top2:
+        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)
+    centerx = obj.px + (obj.hitbox_px + obj.hitbox_width) / 2
+    centery = obj.py + (obj.hitbox_py + obj.hitbox_height) / 2
+    # chid = _test_chunk_position(
+    #     collision_chunks, obj, centerx, centery, chunk_size, chunks_per_row
+    # )
+    offsets = [[0, 0]] + [
+        list(p) for p in product([-1, 0, 1], repeat=2) if p != (0, 0)
+    ]
+    for x, y in offsets:
+        chunk_ids.append(
+            _test_chunk_position(
+                collision_chunks,
+                obj,
+                centerx + x,
+                centery + y,
+                chunk_size,
+                chunks_per_row,
+            )
+        )
+    chunk_ids = list(dict.fromkeys(chunk_ids))
+    # 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/core/database.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict
+
+from ..objects.animated_sprite import AnimatedSprite
+from ..types.damage import Damage
+
+if TYPE_CHECKING:
+    from .engine import MimaEngine
+
+LOG = logging.getLogger(__name__)
+
+
+class Database:
+    engine: MimaEngine
+
+    def __init__(self):
+        self._cache = {}
+        self._known_locale = ""
+        self._active_sprites = []
+
+    def get_usable_data(self, usable_id) -> Dict[str, Any]:
+        if usable_id in self._cache:
+            return self._cache[usable_id]
+
+        data = {}
+        tpl = self.engine.assets.get_template(usable_id)
+
+        data["usable_id"] = tpl.get_string("usable_id")
+        data["name"] = tpl.get_string(f"display_name_{self.engine.rtc.locale}")
+        data["description"] = tpl.get_string(f"description_{self.engine.rtc.locale}")
+        data["sprite_name"] = tpl.get_string("sprite_name")
+        data["dtype"] = Damage[tpl.get_string("dtype", "body").upper()]
+        for pid, prop in tpl.properties.items():
+            if not pid.startswith("attr_"):
+                continue
+            _, attr = pid.split("_", 1)
+            data[attr] = tpl.get(pid)
+        # data["attr_price"] = tpl.get_int("attr_price")
+        # data["attr_swing_timer"] = tpl.get_float("attr_swing_timer")
+        # data["attr_damage"] = tpl.get_int("attr_damage")
+        # data["attr_health_cost"] = tpl.get_int("attr_health_cost")
+        # data["attr_magic_cost"] = tpl.get_int("attr_magic_cost")
+        # data["attr_stamina_cost"] = tpl.get_int("attr_stamina_cost")
+        # data["attr_bomb_cost"] = tpl.get_int("attr_bomb_cost")
+        # data["attr_arrow_cost"] = tpl.get_int("attr_arrow_cost")
+
+        self._cache[usable_id] = data
+        return data
+
+    def get_object_data(self, object_id) -> Dict[str, Any]:
+        return {}
+
+    def get_sprite(self, sprite_id):
+        sprite = AnimatedSprite(sprite_id)
+        self._active_sprites.append(sprite)
+        return sprite