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

mima/backend/pygame_events.py

@@ -1,15 +1,17 @@
 import logging
 import time
-from typing import Dict, List, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 import pygame
 
 from ..types.keys import Key as K
+from ..types.player import Player
 from ..util.constants import AXIS_ACTIVATION, AXIS_DEADZONE, DOUBLE_TAP_SPEED
 from ..util.input_defaults import (
     BUTTONS,
     DEFAULT_JOYSTICK_MAP,
     DEFAULT_KEYBOARD_MAP,
+    DEFAULT_TOUCHSCREEN_MAP,
 )
 
 LOG = logging.getLogger(__name__)
@@ -32,8 +34,9 @@ class PygameUserInput:
 
     def __init__(
         self,
-        key_map: Dict[K, List[str]] = DEFAULT_KEYBOARD_MAP,
-        joystick_map: Dict[K, List[Union[str, int]]] = DEFAULT_JOYSTICK_MAP,
+        key_map: Optional[Dict[K, List[str]]] = None,
+        joystick_map: Optional[Dict[K, List[Union[str, int]]]] = None,
+        joy_to_player: Optional[Dict[int, Player]] = None,
         platform: str = "PC",
     ):
         self._last_keys: Dict[K, bool] = {}
@@ -46,7 +49,17 @@ class PygameUserInput:
         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._key_map: Dict[K, List[int]] = {}
+        self.joystick_to_player: Dict[int, Player] = (
+            joy_to_player
+            if joy_to_player is not None
+            else {
+                0: Player.P1,
+                1: Player.P2,
+                2: Player.P3,
+                4: Player.P4,
+            }
+        )
         self.vd = pygame.Vector2(0, 0)
         self.joystick_input_enabled: bool = True
         if platform == "android":
@@ -62,24 +75,82 @@ class PygameUserInput:
         #         for val in vals:
         #             self._key_map[key].append(getattr(pygame, f"K_{val}"))
         # else:
+        key_map = key_map if key_map is not None else DEFAULT_KEYBOARD_MAP
         for key, vals in key_map.items():
             self._key_map[key] = []
             for val in vals:
+                if len(val) > 1:
+                    val = val.upper()
                 self._key_map[key].append(getattr(pygame, f"K_{val}"))
 
+        # print(self._key_map)
         # 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()
+        if joystick_map is None:
+            self._joystick_map = {}
+            for but in BUTTONS:
+                self._joystick_map[but] = DEFAULT_JOYSTICK_MAP[
+                    K(but.value % 12)
+                ]
+        else:
+            self._joystick_map = joystick_map
+
+        self.joysticks: Dict[Player, Optional[Any]] = {}
+        self._init_joysticks()
         self.width = 0
         self.height = 0
+        self._past_events = {}
+        self._new_events = {}
+        self._collect_all_events = False
 
     def reset(self):
         self._last_keys = self._new_keys.copy()
+        self._past_events = self._new_events.copy()
+        self.all_events = []
+
+    def get_keyboard_map(self) -> Dict[K, List[str]]:
+        key_map: Dict[K, List[str]] = {}
+        for key, mapping in self._key_map.items():
+            key_map[key] = []
+            for val in mapping:
+                key_map[key].append(pygame.key.name(val))
+        return key_map
+
+    def get_joystick_map(self):
+        return self._joystick_map
+
+    def get_key_name(self, val: int):
+        return pygame.key.name(val)
+
+    def update_keyboard_map(self, kbmap: Dict[K, List[str]]):
+        new_keymap: Dict[K, List[int]] = {}
+        try:
+            for key, vals in kbmap.items():
+                new_keymap[key] = []
+                for val in vals:
+                    if len(val) > 1:
+                        val = val.upper()
+                    new_keymap[key].append(getattr(pygame, f"K_{val}"))
+        except Exception as err:
+            LOG.exception(f"Failed to update keyboard map: {err}")
+            return
+        self._key_map = new_keymap
+
+    def update_joystick_map(self, jsmap):
+        self._joystick_map = jsmap
+
+    def update_joysticks(self, reassign: List[Tuple[int, Player]]):
+        self.joystick_to_player = {}
+        for item in reassign:
+            self.joystick_to_player[item[0]] = item[1]
+        # k2d = None
+        # for jid, p in self.joystick_to_player.items():
+        #     if p == player:
+        #         k2d = jid
+        # self.joystick_to_player[joy] = player
+        # self.joystick_to_player[k2d] = None
 
     def process(self, event):
         if event.type in KEYBOARD_EVENTS:
@@ -91,7 +162,15 @@ class PygameUserInput:
         if event.type in TOUCH_EVENTS:
             self._handle_touch(event)
 
+        # print(
+        #     {key: val for key, val in self._last_keys.items() if val},
+        #     {k: v for k, v in self._new_keys.items() if v},
+        # )
+
     def _handle_keyboard(self, event):
+        if self._collect_all_events:
+            self._collect_keyboard_events(event)
+
         if event.type == pygame.KEYDOWN:
             for but, keys in self._key_map.items():
                 if event.key in keys:
@@ -102,78 +181,93 @@ class PygameUserInput:
                 if event.key in keys:
                     self.unset_key(but)
 
+    def _js_real(self, joy, but):
+        return K[f"{self.joystick_to_player[joy].name}_{but.name}"]
+
     def _handle_joystick(self, event):
+        if self._collect_all_events:
+            self._collect_joystick_events(event)
+
         if event.type == pygame.JOYDEVICEREMOVED:
-            self.joystick = None
+            self.joystick = {}
             LOG.info("Gamepad unplugged.")
 
         if event.type == pygame.JOYDEVICEADDED:
-            self._init_joystick()
-            LOG.info(
-                "Detected new gamepad device %s.", self.joystick.get_name()
-            )
+            self._init_joysticks()
+            LOG.info("Detected new gamepad device %s.", self.joysticks)
 
         if event.type == pygame.JOYBUTTONDOWN:
-            if event.joy != 0:
+            if event.joy not in self.joystick_to_player:
                 return
             for but, keys in self._joystick_map.items():
-                if event.button in keys:
+                if (
+                    str(event.button) in keys
+                    and self.joystick_to_player[event.joy] is not None
+                    and self.joystick_to_player[event.joy].name in but.name
+                ):
                     self.set_key(but)
 
         if event.type == pygame.JOYBUTTONUP:
-            if event.joy != 0:
+            if event.joy not in self.joystick_to_player:
                 return
             for but, keys in self._joystick_map.items():
-                if event.button in keys:
+                if (
+                    str(event.button) in keys
+                    and self.joystick_to_player[event.joy] is not None
+                    and self.joystick_to_player[event.joy].name in but.name
+                ):
                     self.unset_key(but)
+
         if event.type == pygame.JOYHATMOTION:
-            if event.joy != 0 or event.hat != 0:
+            if event.joy not in self.joystick_to_player:
                 return
 
             if event.value[0] == 0:
-                self.unset_key(K.LEFT)
-                self.unset_key(K.RIGHT)
+                self.unset_key(self._js_real(event.joy, K.LEFT))
+                self.unset_key(self._js_real(event.joy, K.RIGHT))
             elif event.value[0] == -1:
-                self.set_key(K.LEFT)
-                self.unset_key(K.RIGHT)
+                self.set_key(self._js_real(event.joy, K.LEFT))
+                self.unset_key(self._js_real(event.joy, K.RIGHT))
             else:
-                self.unset_key(K.LEFT)
-                self.set_key(K.RIGHT)
+                self.unset_key(self._js_real(event.joy, K.LEFT))
+                self.set_key(self._js_real(event.joy, K.RIGHT))
 
             if event.value[1] == 0:
-                self.unset_key(K.UP)
-                self.unset_key(K.DOWN)
+                self.unset_key(self._js_real(event.joy, K.UP))
+                self.unset_key(self._js_real(event.joy, K.DOWN))
             elif event.value[1] == 1:
-                self.set_key(K.UP)
-                self.unset_key(K.DOWN)
+                self.set_key(self._js_real(event.joy, K.UP))
+                self.unset_key(self._js_real(event.joy, K.DOWN))
             else:
-                self.unset_key(K.UP)
-                self.set_key(K.DOWN)
+                self.unset_key(self._js_real(event.joy, K.UP))
+                self.set_key(self._js_real(event.joy, K.DOWN))
+
         if event.type == pygame.JOYAXISMOTION:
-            if event.joy != 0:
+            if event.joy not in self.joystick_to_player:
                 return
+
             if event.axis == 0:
                 if event.value < -AXIS_ACTIVATION:
-                    self.set_key(K.LEFT)
-                    self.unset_key(K.RIGHT)
+                    self.set_key(self._js_real(event.joy, K.LEFT))
+                    self.unset_key(self._js_real(event.joy, K.RIGHT))
                 elif event.value > AXIS_ACTIVATION:
-                    self.unset_key(K.LEFT)
-                    self.set_key(K.RIGHT)
+                    self.unset_key(self._js_real(event.joy, K.LEFT))
+                    self.set_key(self._js_real(event.joy, K.RIGHT))
                 elif abs(event.value) < AXIS_DEADZONE:
-                    self.unset_key(K.LEFT)
-                    self.unset_key(K.RIGHT)
+                    self.unset_key(self._js_real(event.joy, K.LEFT))
+                    self.unset_key(self._js_real(event.joy, K.RIGHT))
                 else:
                     pass
             if event.axis == 1:
                 if event.value < -AXIS_ACTIVATION:
-                    self.set_key(K.UP)
-                    self.unset_key(K.DOWN)
+                    self.set_key(self._js_real(event.joy, K.UP))
+                    self.unset_key(self._js_real(event.joy, K.DOWN))
                 elif event.value > AXIS_ACTIVATION:
-                    self.unset_key(K.UP)
-                    self.set_key(K.DOWN)
+                    self.unset_key(self._js_real(event.joy, K.UP))
+                    self.set_key(self._js_real(event.joy, K.DOWN))
                 elif abs(event.value) < AXIS_DEADZONE:
-                    self.unset_key(K.UP)
-                    self.unset_key(K.DOWN)
+                    self.unset_key(self._js_real(event.joy, K.UP))
+                    self.unset_key(self._js_real(event.joy, K.DOWN))
 
     def _handle_touch(self, event):
         finger_pos = pygame.Vector2(
@@ -182,39 +276,57 @@ class PygameUserInput:
 
         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)
+            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.UP:
+                        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
+                    else:
+                        self.set_key(key)
+                        self._right_finger_tap_pos = finger_pos
+                        self._last_right_tap = tap
+
+            # if event.x < 0.0625 and event.y < 0.1111:
+            #     self.set_key(K.L)
+            # elif event.x > 1.0 - 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:
@@ -239,7 +351,7 @@ class PygameUserInput:
                 self.unset_key(K.LEFT)
                 self.unset_key(K.UP)
                 self.unset_key(K.DOWN)
-                self.unset_key(K.R)
+                self.unset_key(K.L)
                 # print(
                 #     f"Left Finger moved {finger_dist} "
                 #     f"({release - self._last_left_tap} s)"
@@ -408,11 +520,17 @@ class PygameUserInput:
         #     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 _init_joysticks(self):
+        for jid in range(pygame.joystick.get_count()):
+            js = pygame.joystick.Joystick(jid)
+            js.init()
+            # p = Player(jid + 1)
+            self.joysticks[js.get_id()] = js
+            LOG.info(
+                "Initialized Joystick #%d: %s",
+                jid,
+                self.joysticks[js.get_id()].get_name(),
+            )
 
     def set_key(self, button: K):
         self._new_keys[button] = True
@@ -420,11 +538,139 @@ class PygameUserInput:
     def unset_key(self, button: K):
         self._new_keys[button] = False
 
-    def new_key_press(self, button: K):
+    def new_key_press(self, button: K, player: Player = Player.P1):
+        button = _button_to_player(button, player)
         return self._new_keys[button] and not self._last_keys[button]
 
-    def key_held(self, button: K):
+    def key_held(self, button: K, player: Player = Player.P1):
+        button = _button_to_player(button, player)
         return self._new_keys[button]
 
-    def new_key_release(self, button: K):
+    def new_key_release(self, button: K, player: Player = Player.P1):
+        button = _button_to_player(button, player)
         return self._last_keys[button] and not self._new_keys[button]
+
+    def get_all_events(self):
+        return self._new_events
+
+    def _collect_keyboard_events(self, event):
+        kid = f"kb_{event.key}"
+        if event.type == pygame.KEYDOWN:
+            self._new_events[kid] = {
+                "type": "keyboard",
+                "id": event.type,
+                "button": event.key,
+                "name": pygame.key.name(event.key),
+            }
+        if event.type == pygame.KEYUP and kid in self._new_events:
+            del self._new_events[kid]
+
+    def _collect_joystick_events(self, event):
+        if event.type == pygame.JOYDEVICEREMOVED:
+            jid = f"js_{event.instance_id}_removed"
+            self._new_events[jid] = {
+                "type": "joystick",
+                "id": event.instance_id,
+                "button": "removed",
+                "name": "removed",
+            }
+        if event.type == pygame.JOYDEVICEADDED:
+            jid = f"js_{event.device_index}_added"
+            self._new_events[jid] = {
+                "type": "joystick",
+                "id": event.device_index,
+                "button": "added",
+                "guid": event.guid,
+            }
+
+        if event.type == pygame.JOYBUTTONDOWN:
+            kid = f"js_{event.joy}_{event.button}"
+
+            self._new_events[kid] = {
+                "type": "joystick",
+                "id": event.instance_id,
+                "joy": event.joy,
+                "button": event.button,
+                "name": self.joysticks[event.joy].get_name(),
+                "power_level": self.joysticks[event.joy].get_power_level(),
+            }
+        if event.type == pygame.JOYBUTTONUP:
+            kid = f"js_{event.joy}_{event.button}"
+            if kid in self._new_events:
+                del self._new_events[kid]
+        if event.type == pygame.JOYHATMOTION:
+            kid = f"js_{event.joy}_{event.hat}"
+            klid = f"{kid}_left"
+            krid = f"{kid}_right"
+            kuid = f"{kid}_up"
+            kdid = f"{kid}_down"
+            if event.value[0] == 0:
+                if klid in self._new_events:
+                    del self._new_events[klid]
+                if krid in self._new_events:
+                    del self._new_events[krid]
+            elif event.value[0] == -1:
+                self._new_events[klid] = {
+                    "type": "joystick",
+                    "id": event.instance_id,
+                    "joy": event.joy,
+                    "button": "left",
+                    "hat": event.hat,
+                    "value": event.value[0],
+                    "name": self.joysticks[event.joy].get_name(),
+                    "power_level": self.joysticks[event.joy].get_power_level(),
+                }
+                if krid in self._new_events:
+                    del self._new_events[krid]
+            else:
+                self._new_events[krid] = {
+                    "type": "joystick",
+                    "id": event.instance_id,
+                    "joy": event.joy,
+                    "button": "right",
+                    "hat": event.hat,
+                    "value": event.value[0],
+                    "name": self.joysticks[event.joy].get_name(),
+                    "power_level": self.joysticks[event.joy].get_power_level(),
+                }
+                if klid in self._new_events:
+                    del self._new_events[klid]
+
+            if event.value[1] == 0:
+                if kuid in self._new_events:
+                    del self._new_events[kuid]
+                if kdid in self._new_events:
+                    del self._new_events[kdid]
+            elif event.value[1] == 1:
+                self._new_events[kuid] = {
+                    "type": "joystick",
+                    "id": event.instance_id,
+                    "joy": event.joy,
+                    "button": "up",
+                    "hat": event.hat,
+                    "value": event.value[1],
+                    "name": self.joysticks[event.joy].get_name(),
+                    "power_level": self.joysticks[event.joy].get_power_level(),
+                }
+                if kdid in self._new_events:
+                    del self._new_events[kdid]
+            else:
+                self._new_events[kdid] = {
+                    "type": "joystick",
+                    "id": event.instance_id,
+                    "joy": event.joy,
+                    "button": "down",
+                    "hat": event.hat,
+                    "value": event.value[1],
+                    "name": self.joysticks[event.joy].get_name(),
+                    "power_level": self.joysticks[event.joy].get_power_level(),
+                }
+                if kuid in self._new_events:
+                    del self._new_events[kuid]
+
+    def trigger_all_events_collection(self, active: bool = True):
+        self._collect_all_events = active
+
+
+def _button_to_player(button: K, player: Player):
+    return K(button.value + 12 * player.value)