mima-engine 0.2.2__tar.gz → 0.2.4__tar.gz

{mima_engine-0.2.2 → mima_engine-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: mima-engine
-Version: 0.2.2
+Version: 0.2.4
 Summary: A game engine based on pygame.
 Author-email: Stephan Balduin <stephan.balduin@mailbox.org>
 Classifier: Programming Language :: Python :: 3

mima_engine-0.2.4/src/mima/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.2.4"
+
+from .core.engine import MimaEngine
+from .core.mode_engine import MimaModeEngine

{mima_engine-0.2.2 → mima_engine-0.2.4}/src/mima/backend/pygame_assets.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import csv
 import logging
 import os
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional
 
 import pygame
 
@@ -21,9 +21,10 @@ LOG = logging.getLogger(__name__)
 class PygameAssets:
     def __init__(self, rtc: RuntimeConfig, init_file: str):
         self.rtc = rtc
-        self._sprites: Dict[str, pygame.Surface] = {}
+        self._images: Dict[str, pygame.Surface] = {}
         self._tilesets: Dict[str, TiledTileset] = {}
         self._templates: Dict[str, TiledTemplate] = {}
+        self._sprite_sheets: Dict[str, Dict[Any]] = {}
         self._maps: Dict[str, TiledMap] = {}
         self._music: Dict[str, str] = {}
         self._sound: Dict[str, str] = {}
@@ -145,17 +146,17 @@ class PygameAssets:
         # print(name, filename)
 
         possible_name = os.path.split(filename)[-1][:-4]
-        if possible_name in self._sprites:
+        if possible_name in self._images:
             LOG.warning(
                 "Sprite '%s' is possibly already loaded with name %s.",
                 filename,
                 possible_name,
             )
-        elif name in self._sprites:
+        elif name in self._images:
             LOG.debug("Sprite '%s' already loaded. Skipping.")
             return name
 
-        self._sprites[name] = self._load_sprite_from_disk(filename)
+        self._images[name] = self._load_sprite_from_disk(filename)
 
         return name
 
@@ -182,7 +183,59 @@ class PygameAssets:
         elif name in self._tilesets:
             LOG.debug("Tileset at '%s' already loaded. Skipping", filename)
             return name
-        self._tilesets[name] = TiledTileset(name, filename)
+        ts = TiledTileset(name, filename)
+        self._tilesets[name] = ts
+
+        # Load sprite sheets
+        for tile in ts.tiles:
+            if not tile.sprite_name:
+                continue
+
+            self._sprite_sheets.setdefault(tile.sprite_name, {})
+            data = {
+                "duration": [],
+                "ox": [],
+                "oy": [],
+                "image": [],
+                "width": [],
+                "height": [],
+            }
+            if tile.animated:
+                for frame in tile._frames:
+                    data["duration"].append(frame.duration)
+                    data["ox"].append(frame.frame_id % ts.columns)
+                    data["oy"].append(frame.frame_id // ts.columns)
+                    data["image"].append(ts.image_name)
+                    data["width"].append(ts.tile_width)
+                    data["height"].append(ts.tile_height)
+            else:
+                data["duration"].append(1000)
+                data["ox"].append(tile.tile_id % ts.columns)
+                data["oy"].append(tile.tile_id // ts.columns)
+                data["image"].append(ts.image_name)
+                data["width"].append(ts.tile_width)
+                data["height"].append(ts.tile_height)
+
+            self._sprite_sheets[tile.sprite_name].setdefault(
+                tile.graphic_state, {}
+            )
+            self._sprite_sheets[tile.sprite_name][tile.graphic_state][
+                tile.facing_direction
+            ] = data
+            LOG.debug(
+                "%s",
+                {
+                    "operation": "add frames",
+                    "image": ts.image_name,
+                    "sprite": tile.sprite_name,
+                    "graphic_state": tile.graphic_state.name,
+                    "direction": tile.facing_direction.name,
+                    "frame_data": data,
+                },
+            )
+
+        # for sprite_name in ts.sprite_names:
+        #     self._sprites[sprite_name] = {}
         return name
 
     def _load_template(self, name, filename=None):
@@ -191,7 +244,7 @@ class PygameAssets:
 
         if not os.path.isfile(filename):
             filename = os.path.join(
-                self._data_path, "templates", os.path.split(filename)[-1]
+                self.data_path, "templates", os.path.split(filename)[-1]
             )
 
         possible_name = os.path.split(filename)[-1][:-3]
@@ -287,13 +340,18 @@ class PygameAssets:
                 name_color = f"{name}_color"
             else:
                 name_color = name
-            return self._sprites.get(name_color, self._sprites[name])
+            return self._images.get(name_color, self._images[name])
+
+    def get_sprite_data(self, sprite_id):
+        if not sprite_id:
+            return {}
+        return self._sprite_sheets[sprite_id]
 
     def new_map(self, name, tilemap: Tilemap):
         self._maps[name] = tilemap
 
     def new_sprite(self, name, surface: pygame.Surface):
-        self._sprites[name] = surface
+        self._images[name] = surface
 
     def get_tileset(self, name):
         if name not in self._tilesets:

{mima_engine-0.2.2 → mima_engine-0.2.4}/src/mima/backend/pygame_backend.py

@@ -464,8 +464,11 @@ class PygameBackend:
             )
             idx += 1
 
-    def draw_pixel(self, px: float, py: float, color: Color):
-        self.display.set_at((int(px), int(py)), color.getRGB())
+    def draw_pixel(
+        self, px: float, py: float, color: Color, camera_name=C_DISPLAY
+    ):
+        display = self._cameras[camera_name].view
+        display.set_at((int(px), int(py)), color.getRGB())
 
     def draw_camera(self, name, px, py, scale):
         self.display.blit(

{mima_engine-0.2.2 → mima_engine-0.2.4}/src/mima/backend/pygame_events.py

@@ -13,6 +13,8 @@ from ..util.input_defaults import (
     DEFAULT_KEYBOARD_MAP,
     DEFAULT_TOUCHSCREEN_MAP,
 )
+from .touch_control_scheme_a import TouchControlSchemeA
+from .touch_control_scheme_b import TouchControlSchemeB
 
 LOG = logging.getLogger(__name__)
 
@@ -41,14 +43,15 @@ class PygameUserInput:
     ):
         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._touch_control = TouchControlSchemeB()
+        # 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, List[int]] = {}
         self.joystick_to_player: Dict[int, Player] = (
             joy_to_player
@@ -104,6 +107,7 @@ class PygameUserInput:
         self._past_events = {}
         self._new_events = {}
         self._collect_all_events = False
+        self.enable_touch_controls = False
 
     def reset(self):
         self._last_keys = self._new_keys.copy()
@@ -159,7 +163,8 @@ class PygameUserInput:
         if event.type in JOYSTICK_EVENTS and self.joystick_input_enabled:
             self._handle_joystick(event)
 
-        if event.type in TOUCH_EVENTS:
+        # self._touch_control.update(self.width, self.height)
+        if self.enable_touch_controls and event.type in TOUCH_EVENTS:
             self._handle_touch(event)
 
         # print(
@@ -270,194 +275,202 @@ class PygameUserInput:
                     self.unset_key(self._js_real(event.joy, K.DOWN))
 
     def _handle_touch(self, event):
-        finger_pos = pygame.Vector2(
-            event.x * self.width, event.y * self.height
+        set_keys, unset_keys = self._touch_control.handle_touch(
+            event, self.width, self.height
         )
+        for key in unset_keys:
+            self.unset_key(key)
+        for key in set_keys:
+            self.set_key(key)
 
-        if event.type == pygame.FINGERDOWN:
-            tap = time.time()
-            for key, area in DEFAULT_TOUCHSCREEN_MAP.items():
+        # finger_pos = pygame.Vector2(
+        #     event.x * self.width, event.y * self.height
+        # )
 
-                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 = finger_pos
-                        if tap - self._last_left_tap < DOUBLE_TAP_SPEED:
-                            # print("Left Double Tap")
-                            self.set_key(K.P1_SELECT)
-                        self._last_left_tap = tap
-                    elif key == K.P1_L:
-                        self.set_key(K.P1_L)
-                    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:
-            #         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.P1_SELECT)
-                self.unset_key(K.P1_RIGHT)
-                self.unset_key(K.P1_LEFT)
-                self.unset_key(K.P1_UP)
-                self.unset_key(K.P1_DOWN)
-                self.unset_key(K.P1_L)
-                # print(
-                #     f"Left Finger moved {finger_dist} "
-                #     f"({release - self._last_left_tap} s)"
-                # )
-            else:
-                self.unset_key(K.P1_START)
-                self.unset_key(K.P1_A)
-                self.unset_key(K.P1_B)
-                self.unset_key(K.P1_Y)
-                self.unset_key(K.P1_X)
-                self.unset_key(K.P1_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.P1_RIGHT)
-                self.unset_key(K.P1_LEFT)
-                self.unset_key(K.P1_UP)
-                self.unset_key(K.P1_DOWN)
-                if abs(vd.x) > 2 * abs(vd.y):
-                    # Horizontal
-                    if vd.x > 5.0:
-                        self.set_key(K.P1_RIGHT)
-                        self.unset_key(K.P1_LEFT)
-                        self.unset_key(K.P1_UP)
-                        self.unset_key(K.P1_DOWN)
-                    elif vd.x < -5.0:
-                        self.set_key(K.P1_LEFT)
-                        self.unset_key(K.P1_RIGHT)
-                        self.unset_key(K.P1_UP)
-                        self.unset_key(K.P1_DOWN)
-                elif abs(vd.x) * 2 < abs(vd.y):
-                    # Vertical
-                    if vd.y > 5.0:
-                        self.unset_key(K.P1_RIGHT)
-                        self.unset_key(K.P1_LEFT)
-                        self.unset_key(K.P1_UP)
-                        self.set_key(K.P1_DOWN)
-                    elif vd.y < -5.0:
-                        self.unset_key(K.P1_LEFT)
-                        self.unset_key(K.P1_RIGHT)
-                        self.set_key(K.P1_UP)
-                        self.unset_key(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:
-                        self.set_key(K.P1_LEFT)
-                    elif vd.x > 0:
-                        self.set_key(K.P1_RIGHT)
-                    if vd.y < 0:
-                        self.set_key(K.P1_UP)
-                    elif vd.y > 0:
-                        self.set_key(K.P1_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
+        # if event.type == pygame.FINGERDOWN:
+        #     tap = 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 = finger_pos
+        #                 if tap - self._last_left_tap < DOUBLE_TAP_SPEED:
+        #                     # print("Left Double Tap")
+        #                     self.set_key(K.P1_SELECT)
+        #                 self._last_left_tap = tap
+        #             elif key == K.P1_L:
+        #                 self.set_key(K.P1_L)
+        #             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:
+        #     #         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.P1_SELECT)
+        #         self.unset_key(K.P1_RIGHT)
+        #         self.unset_key(K.P1_LEFT)
+        #         self.unset_key(K.P1_UP)
+        #         self.unset_key(K.P1_DOWN)
+        #         self.unset_key(K.P1_L)
+        #         # print(
+        #         #     f"Left Finger moved {finger_dist} "
+        #         #     f"({release - self._last_left_tap} s)"
+        #         # )
+        #     else:
+        #         self.unset_key(K.P1_START)
+        #         self.unset_key(K.P1_A)
+        #         self.unset_key(K.P1_B)
+        #         self.unset_key(K.P1_Y)
+        #         self.unset_key(K.P1_X)
+        #         self.unset_key(K.P1_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.P1_RIGHT)
+        #         self.unset_key(K.P1_LEFT)
+        #         self.unset_key(K.P1_UP)
+        #         self.unset_key(K.P1_DOWN)
+        #         if abs(vd.x) > 2 * abs(vd.y):
+        #             # Horizontal
+        #             if vd.x > 5.0:
+        #                 self.set_key(K.P1_RIGHT)
+        #                 self.unset_key(K.P1_LEFT)
+        #                 self.unset_key(K.P1_UP)
+        #                 self.unset_key(K.P1_DOWN)
+        #             elif vd.x < -5.0:
+        #                 self.set_key(K.P1_LEFT)
+        #                 self.unset_key(K.P1_RIGHT)
+        #                 self.unset_key(K.P1_UP)
+        #                 self.unset_key(K.P1_DOWN)
+        #         elif abs(vd.x) * 2 < abs(vd.y):
+        #             # Vertical
+        #             if vd.y > 5.0:
+        #                 self.unset_key(K.P1_RIGHT)
+        #                 self.unset_key(K.P1_LEFT)
+        #                 self.unset_key(K.P1_UP)
+        #                 self.set_key(K.P1_DOWN)
+        #             elif vd.y < -5.0:
+        #                 self.unset_key(K.P1_LEFT)
+        #                 self.unset_key(K.P1_RIGHT)
+        #                 self.set_key(K.P1_UP)
+        #                 self.unset_key(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:
+        #                 self.set_key(K.P1_LEFT)
+        #             elif vd.x > 0:
+        #                 self.set_key(K.P1_RIGHT)
+        #             if vd.y < 0:
+        #                 self.set_key(K.P1_UP)
+        #             elif vd.y > 0:
+        #                 self.set_key(K.P1_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:
@@ -674,6 +687,9 @@ class PygameUserInput:
     def trigger_all_events_collection(self, active: bool = True):
         self._collect_all_events = active
 
+    def get_touch_state(self):
+        return self._touch_control.get_touch_state()
+
 
 def _button_to_player(button: K, player: Player):
     return K(button.value + 12 * player.value)