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

{mima_engine-0.2.3 → 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.3
+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.3 → mima_engine-0.2.4}/src/mima/__init__.py

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

{mima_engine-0.2.3 → 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)

mima_engine-0.2.4/src/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 {}