mima-engine 0.1.0__py3-none-any.whl

mima/backend/pygame_events.py

@@ -0,0 +1,430 @@
+import logging
+import time
+from typing import Dict, List, Union
+
+import pygame
+
+from ..types.keys import Key as K
+from ..util.constants import AXIS_ACTIVATION, AXIS_DEADZONE, DOUBLE_TAP_SPEED
+from ..util.input_defaults import (
+    BUTTONS,
+    DEFAULT_JOYSTICK_MAP,
+    DEFAULT_KEYBOARD_MAP,
+)
+
+LOG = logging.getLogger(__name__)
+
+KEYBOARD_EVENTS = [pygame.KEYUP, pygame.KEYDOWN]
+JOYSTICK_EVENTS = [
+    pygame.JOYDEVICEADDED,
+    pygame.JOYDEVICEREMOVED,
+    pygame.JOYBUTTONUP,
+    pygame.JOYBUTTONDOWN,
+    pygame.JOYAXISMOTION,
+    pygame.JOYHATMOTION,
+]
+TOUCH_EVENTS = [pygame.FINGERUP, pygame.FINGERDOWN, pygame.FINGERMOTION]
+SDL2_BACKGROUND_EVENTS = [259, 260, 261, 262]
+
+
+class PygameUserInput:
+    """A class that manages keys and key events."""
+
+    def __init__(
+        self,
+        key_map: Dict[K, List[str]] = DEFAULT_KEYBOARD_MAP,
+        joystick_map: Dict[K, List[Union[str, int]]] = DEFAULT_JOYSTICK_MAP,
+        platform: str = "PC",
+    ):
+        self._last_keys: Dict[K, bool] = {}
+        self._new_keys: Dict[K, bool] = {but: False for but in BUTTONS}
+        self._left_finger_tap_pos: pygame.Vector2 = pygame.Vector2(0, 0)
+        self._right_finger_tap_pos: pygame.Vector2 = pygame.Vector2(0, 0)
+        self._left_finger_pos: pygame.Vector2 = pygame.Vector2(0, 0)
+        self._right_finger_pos: pygame.Vector2 = pygame.Vector2(0, 0)
+        self._last_left_tap: float = 0.0
+        self._last_right_tap: float = 0.0
+        self._last_left_motion: float = 0.0
+        self._last_right_motion: float = 0.0
+        self._key_map: Dict[K, int] = {}
+        self.vd = pygame.Vector2(0, 0)
+        self.joystick_input_enabled: bool = True
+        if platform == "android":
+            # Disable motion control
+            # FIXME allow external controllers
+            self.joystick_input_enabled = False
+        # self._fingers: List[pygame.Vector2] = []
+
+        # if key_map is None:
+        #     self._key_map = dict()
+        #     for key, vals in RuntimeConfig().keymap.items():
+        #         self._key_map[key] = list()
+        #         for val in vals:
+        #             self._key_map[key].append(getattr(pygame, f"K_{val}"))
+        # else:
+        for key, vals in key_map.items():
+            self._key_map[key] = []
+            for val in vals:
+                self._key_map[key].append(getattr(pygame, f"K_{val}"))
+
+        # self._key_map = key_map
+        # if joystick_map is None:
+        #     self._joystick_map = DEFAULT_JOYSTICK_MAP
+        # else:
+        self._joystick_map = joystick_map
+
+        self.joystick = None
+        self._init_joystick()
+        self.width = 0
+        self.height = 0
+
+    def reset(self):
+        self._last_keys = self._new_keys.copy()
+
+    def process(self, event):
+        if event.type in KEYBOARD_EVENTS:
+            self._handle_keyboard(event)
+
+        if event.type in JOYSTICK_EVENTS and self.joystick_input_enabled:
+            self._handle_joystick(event)
+
+        if event.type in TOUCH_EVENTS:
+            self._handle_touch(event)
+
+    def _handle_keyboard(self, event):
+        if event.type == pygame.KEYDOWN:
+            for but, keys in self._key_map.items():
+                if event.key in keys:
+                    self.set_key(but)
+
+        if event.type == pygame.KEYUP:
+            for but, keys in self._key_map.items():
+                if event.key in keys:
+                    self.unset_key(but)
+
+    def _handle_joystick(self, event):
+        if event.type == pygame.JOYDEVICEREMOVED:
+            self.joystick = None
+            LOG.info("Gamepad unplugged.")
+
+        if event.type == pygame.JOYDEVICEADDED:
+            self._init_joystick()
+            LOG.info(
+                "Detected new gamepad device %s.", self.joystick.get_name()
+            )
+
+        if event.type == pygame.JOYBUTTONDOWN:
+            if event.joy != 0:
+                return
+            for but, keys in self._joystick_map.items():
+                if event.button in keys:
+                    self.set_key(but)
+
+        if event.type == pygame.JOYBUTTONUP:
+            if event.joy != 0:
+                return
+            for but, keys in self._joystick_map.items():
+                if event.button in keys:
+                    self.unset_key(but)
+        if event.type == pygame.JOYHATMOTION:
+            if event.joy != 0 or event.hat != 0:
+                return
+
+            if event.value[0] == 0:
+                self.unset_key(K.LEFT)
+                self.unset_key(K.RIGHT)
+            elif event.value[0] == -1:
+                self.set_key(K.LEFT)
+                self.unset_key(K.RIGHT)
+            else:
+                self.unset_key(K.LEFT)
+                self.set_key(K.RIGHT)
+
+            if event.value[1] == 0:
+                self.unset_key(K.UP)
+                self.unset_key(K.DOWN)
+            elif event.value[1] == 1:
+                self.set_key(K.UP)
+                self.unset_key(K.DOWN)
+            else:
+                self.unset_key(K.UP)
+                self.set_key(K.DOWN)
+        if event.type == pygame.JOYAXISMOTION:
+            if event.joy != 0:
+                return
+            if event.axis == 0:
+                if event.value < -AXIS_ACTIVATION:
+                    self.set_key(K.LEFT)
+                    self.unset_key(K.RIGHT)
+                elif event.value > AXIS_ACTIVATION:
+                    self.unset_key(K.LEFT)
+                    self.set_key(K.RIGHT)
+                elif abs(event.value) < AXIS_DEADZONE:
+                    self.unset_key(K.LEFT)
+                    self.unset_key(K.RIGHT)
+                else:
+                    pass
+            if event.axis == 1:
+                if event.value < -AXIS_ACTIVATION:
+                    self.set_key(K.UP)
+                    self.unset_key(K.DOWN)
+                elif event.value > AXIS_ACTIVATION:
+                    self.unset_key(K.UP)
+                    self.set_key(K.DOWN)
+                elif abs(event.value) < AXIS_DEADZONE:
+                    self.unset_key(K.UP)
+                    self.unset_key(K.DOWN)
+
+    def _handle_touch(self, event):
+        finger_pos = pygame.Vector2(
+            event.x * self.width, event.y * self.height
+        )
+
+        if event.type == pygame.FINGERDOWN:
+            tap = time.time()
+            if event.x < 0.0625 and event.y < 0.1111:
+                self.set_key(K.R)
+            elif event.x < 0.5:
+                # print(f"Left Finger Down: {finger_pos}")
+                self._left_finger_tap_pos = finger_pos
+
+                if tap - self._last_left_tap < DOUBLE_TAP_SPEED:
+                    # print("Left Double Tap")
+                    self.set_key(K.SELECT)
+                self._last_left_tap = tap
+                #     self._left_finger_pos.x = event.x
+                #     self._left_finger_pos.y = event.y
+
+                #     if tap - self._last_left_tap < 0.2:
+                #         print("Left Double Tap")
+                #         # self._set_key(K.START)
+                #         # self._unset_key(K.RIGHT)
+                #         # self._unset_key(K.LEFT)
+                #         # self._unset_key(K.UP)
+                #         # self._unset_key(K.DOWN)
+            else:
+                self._right_finger_tap_pos = finger_pos
+
+                # if tap - self._last_right_tap < DOUBLE_TAP_SPEED:
+                #     # print("Right Double Tap")
+                #     self.set_key(K.SELECT)
+                self._last_right_tap = tap
+                if event.y < 0.3:
+                    self.set_key(K.START)
+                elif event.x < 0.75:
+                    self.set_key(K.B)
+                else:
+                    self.set_key(K.A)
+            #     self._right_finger_pos.x = event.x
+            #     self._right_finger_pos.y = event.y
+            #     if tap - self._last_right_tap < 0.2:
+            #         print("Right Double Tap")
+
+        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")
+                #     # self.set_key(K.START)
+
+                self.unset_key(K.SELECT)
+                self.unset_key(K.RIGHT)
+                self.unset_key(K.LEFT)
+                self.unset_key(K.UP)
+                self.unset_key(K.DOWN)
+                self.unset_key(K.R)
+                # print(
+                #     f"Left Finger moved {finger_dist} "
+                #     f"({release - self._last_left_tap} s)"
+                # )
+            else:
+                self.unset_key(K.START)
+                self.unset_key(K.A)
+                self.unset_key(K.B)
+                self.unset_key(K.Y)
+                self.unset_key(K.X)
+                self.unset_key(K.R)
+            # print(f"Right Finger Up: {finger_pos}")
+            # if (
+            #     SINGLE_TAP_MIN
+            #     < release - self._last_right_tap
+            #     < SINGLE_TAP_MAX
+            # ) and finger_dist < 2.5:
+            #     print("Right Single Tap")
+
+            # print(
+            #     f"Left Finger moved {finger_dist} "
+            #     f"({release - self._last_left_tap} s)"
+            # )
+            #
+            # if event.x < 0.5:
+            #     if 0.1 < release - self._last_left_tap < 0.25:
+            #         print("Left Single Tap")
+
+            #     self._left_finger_pos.x = 0
+            #     self._left_finger_pos.y = 0
+            #     self._unset_key(K.DOWN)
+            #     self._unset_key(K.LEFT)
+            #     self._unset_key(K.UP)
+            #     self._unset_key(K.RIGHT)
+            #     self._unset_key(K.START)
+            # else:
+            #     if 0.1 < release - self._last_right_tap < 0.25:
+            #         print("Right Single Tap")
+
+            #     self._unset_key(K.A)
+            #     self._unset_key(K.B)
+        if event.type == pygame.FINGERMOTION:
+            if event.x < 0.5:
+                vd = finger_pos - self._left_finger_tap_pos
+                self.unset_key(K.RIGHT)
+                self.unset_key(K.LEFT)
+                self.unset_key(K.UP)
+                self.unset_key(K.DOWN)
+                if abs(vd.x) > 2 * abs(vd.y):
+                    # Horizontal
+                    if vd.x > 5.0:
+                        self.set_key(K.RIGHT)
+                        self.unset_key(K.LEFT)
+                        self.unset_key(K.UP)
+                        self.unset_key(K.DOWN)
+                    elif vd.x < -5.0:
+                        self.set_key(K.LEFT)
+                        self.unset_key(K.RIGHT)
+                        self.unset_key(K.UP)
+                        self.unset_key(K.DOWN)
+                elif abs(vd.x) * 2 < abs(vd.y):
+                    # Vertical
+                    if vd.y > 5.0:
+                        self.unset_key(K.RIGHT)
+                        self.unset_key(K.LEFT)
+                        self.unset_key(K.UP)
+                        self.set_key(K.DOWN)
+                    elif vd.y < -5.0:
+                        self.unset_key(K.LEFT)
+                        self.unset_key(K.RIGHT)
+                        self.set_key(K.UP)
+                        self.unset_key(K.DOWN)
+                elif abs(vd.x) * 1.05 > abs(vd.y) or abs(vd.x) < 1.05 * abs(
+                    vd.y
+                ):
+                    if vd.x < 0:
+                        self.set_key(K.LEFT)
+                    elif vd.x > 0:
+                        self.set_key(K.RIGHT)
+                    if vd.y < 0:
+                        self.set_key(K.UP)
+                    elif vd.y > 0:
+                        self.set_key(K.DOWN)
+                # else:
+                #     vd = finger_pos - self._right_finger_tap_pos
+                #     self.unset_key(K.A)
+                #     self.unset_key(K.B)
+                #     self.unset_key(K.Y)
+                #     self.unset_key(K.X)
+                #     if abs(vd.x) > 2 * abs(vd.y):
+                #         # Horizontal
+                #         if vd.x > 5.0:
+                #             self.set_key(K.Y)
+                #         elif vd.x < -5.0:
+                #             self.set_key(K.B)
+                #     elif abs(vd.x) * 2 < abs(vd.y):
+                #         # Vertical
+                #         if vd.y > 5.0:
+                #             self.set_key(K.A)
+                #         elif vd.y < -5.0:
+                #             self.set_key(K.X)
+
+                self.vd = vd
+
+    def _handle_mouse(self, event):
+        # if event.type == pygame.MOUSEBUTTONDOWN:
+        #     if 0 <= event.pos[0] < 16 and 80 <= event.pos[1] < 96:
+        #         self._unset_key(K.RIGHT)
+        #         self._set_key(K.LEFT)
+        #         self._unset_key(K.UP)
+        #         self._unset_key(K.DOWN)
+        #     elif 0 <= event.pos[0] < 16 and 64 <= event.pos[1] < 80:
+        #         self._unset_key(K.RIGHT)
+        #         self._set_key(K.LEFT)
+        #         self._set_key(K.UP)
+        #         self._unset_key(K.DOWN)
+        #     elif 16 <= event.pos[0] < 32 and 64 <= event.pos[1] < 80:
+        #         self._unset_key(K.RIGHT)
+        #         self._unset_key(K.LEFT)
+        #         self._set_key(K.UP)
+        #         self._unset_key(K.DOWN)
+        #     elif 32 <= event.pos[0] < 48 and 64 <= event.pos[1] < 80:
+        #         self._set_key(K.RIGHT)
+        #         self._unset_key(K.LEFT)
+        #         self._set_key(K.UP)
+        #         self._unset_key(K.DOWN)
+        #     elif 32 <= event.pos[0] < 48 and 80 <= event.pos[1] < 96:
+        #         self._set_key(K.RIGHT)
+        #         self._unset_key(K.LEFT)
+        #         self._unset_key(K.UP)
+        #         self._unset_key(K.DOWN)
+        #     elif 32 <= event.pos[0] < 48 and 96 <= event.pos[1] < 112:
+        #         self._set_key(K.RIGHT)
+        #         self._unset_key(K.LEFT)
+        #         self._unset_key(K.UP)
+        #         self._set_key(K.DOWN)
+        #     elif 16 <= event.pos[0] < 32 and 96 <= event.pos[1] < 112:
+        #         self._unset_key(K.RIGHT)
+        #         self._unset_key(K.LEFT)
+        #         self._unset_key(K.UP)
+        #         self._set_key(K.DOWN)
+        #     elif 0 <= event.pos[0] < 16 and 96 <= event.pos[1] < 112:
+        #         self._unset_key(K.RIGHT)
+        #         self._set_key(K.LEFT)
+        #         self._unset_key(K.UP)
+        #         self._set_key(K.DOWN)
+        #     if 112 <= event.pos[0] < 144 and 0 <= event.pos[1] < 32:
+        #         self._set_key(K.START)
+        #         self._unset_key(K.RIGHT)
+        #         self._unset_key(K.LEFT)
+        #         self._unset_key(K.UP)
+        #         self._unset_key(K.DOWN)
+        #     if 240 <= event.pos[0] < 256 and 80 <= event.pos[1] < 112:
+        #         self._set_key(K.A)
+        #         self._unset_key(K.RIGHT)
+        #         self._unset_key(K.LEFT)
+        #         self._unset_key(K.UP)
+        #         self._unset_key(K.DOWN)
+
+        # if event.type == pygame.MOUSEBUTTONUP:
+        #     self._unset_key(K.DOWN)
+        #     self._unset_key(K.LEFT)
+        #     self._unset_key(K.UP)
+        #     self._unset_key(K.RIGHT)
+        #     self._unset_key(K.START)
+        #     self._unset_key(K.A)
+        pass
+
+    def _init_joystick(self):
+        if pygame.joystick.get_count() > 0:
+            self.joystick = pygame.joystick.Joystick(0)
+            self.joystick.init()
+            LOG.info("Initialized Joystick %s.", self.joystick.get_name())
+
+    def set_key(self, button: K):
+        self._new_keys[button] = True
+
+    def unset_key(self, button: K):
+        self._new_keys[button] = False
+
+    def new_key_press(self, button: K):
+        return self._new_keys[button] and not self._last_keys[button]
+
+    def key_held(self, button: K):
+        return self._new_keys[button]
+
+    def new_key_release(self, button: K):
+        return self._last_keys[button] and not self._new_keys[button]

mima/collision.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, 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
+
+if TYPE_CHECKING:
+    from .engine import MimaEngine
+    from .view.scene import Scene
+
+
+def check_object_to_map_collision(
+    elapsed_time: float,
+    obj: Dynamic,
+    tilemap: Tilemap,
+    new_px: float,
+    new_py: float,
+) -> 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):
+            # 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):
+            # 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,
+) -> bool:
+    if tilemap.is_solid(left, top, layer):
+        return True
+    if tilemap.is_solid(left, bottom, layer):
+        return True
+    if tilemap.is_solid(right, top, layer):
+        return True
+    if tilemap.is_solid(right, bottom, layer):
+        return True
+
+    return False
+
+
+def check_object_to_object_collision(
+    engine: MimaEngine,
+    scene: Scene,
+    obj: Dynamic,
+    new_px: float,
+    new_py: float,
+    other: Dynamic,
+) -> 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
+
+        if collided_with_dyn:
+            other.on_interaction(obj, Nature.WALK)
+
+    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)
+        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)
+
+    return new_px, new_py
+
+
+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