mima-engine 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of mima-engine might be problematic. Click here for more details.

Files changed (26) hide show
  1. mima/__init__.py +1 -1
  2. mima/backend/pygame_backend.py +4 -1
  3. mima/backend/pygame_events.py +210 -194
  4. mima/backend/touch_control_scheme_a.py +126 -0
  5. mima/backend/touch_control_scheme_b.py +132 -0
  6. mima/core/collision.py +46 -23
  7. mima/core/engine.py +33 -14
  8. mima/core/mode_engine.py +7 -2
  9. mima/objects/creature.py +9 -3
  10. mima/objects/effects/debug_box.py +11 -2
  11. mima/objects/world/container.py +1 -1
  12. mima/objects/world/oneway.py +34 -8
  13. mima/objects/world/pickup.py +8 -2
  14. mima/objects/world/switch.py +20 -4
  15. mima/scripts/commands/oneway_move.py +4 -3
  16. mima/scripts/commands/save_game.py +1 -0
  17. mima/states/game_state.py +60 -35
  18. mima/util/constants.py +5 -3
  19. mima/util/input_defaults.py +12 -0
  20. mima/view/mima_mode.py +60 -19
  21. mima/view/mima_scene.py +6 -0
  22. mima/view/mima_window.py +91 -0
  23. {mima_engine-0.2.3.dist-info → mima_engine-0.2.5.dist-info}/METADATA +2 -2
  24. {mima_engine-0.2.3.dist-info → mima_engine-0.2.5.dist-info}/RECORD +26 -24
  25. {mima_engine-0.2.3.dist-info → mima_engine-0.2.5.dist-info}/WHEEL +1 -1
  26. {mima_engine-0.2.3.dist-info → mima_engine-0.2.5.dist-info}/top_level.txt +0 -0
mima/__init__.py CHANGED
@@ -1,4 +1,4 @@
1
- __version__ = "0.2.3"
1
+ __version__ = "0.2.5"
2
2
 
3
3
  from .core.engine import MimaEngine
4
4
  from .core.mode_engine import MimaModeEngine
mima/backend/pygame_backend.py CHANGED
@@ -87,6 +87,7 @@ class PygameBackend:
87
87
  fullscreen: bool = False,
88
88
  target_fps: int = 60,
89
89
  resizeable: bool = False,
90
+ no_scaled_flag: bool = False,
90
91
  ):
91
92
  LOG.info("Constructing window.")
92
93
  self.render_width, self.display_width = width, width
@@ -96,7 +97,9 @@ class PygameBackend:
96
97
 
97
98
  flags = pygame.HWSURFACE | pygame.DOUBLEBUF
98
99
  if fullscreen:
99
- flags = flags | pygame.FULLSCREEN | pygame.SCALED
100
+ flags = flags | pygame.FULLSCREEN
101
+ if not no_scaled_flag:
102
+ flags = flags | pygame.SCALED
100
103
  self.pixel_size = -1 # Calculate later
101
104
  elif pixel_size == 0:
102
105
  flags = flags | pygame.SCALED
mima/backend/pygame_events.py CHANGED
@@ -13,6 +13,8 @@ from ..util.input_defaults import (
13
13
  DEFAULT_KEYBOARD_MAP,
14
14
  DEFAULT_TOUCHSCREEN_MAP,
15
15
  )
16
+ from .touch_control_scheme_a import TouchControlSchemeA
17
+ from .touch_control_scheme_b import TouchControlSchemeB
16
18
 
17
19
  LOG = logging.getLogger(__name__)
18
20
 
@@ -41,14 +43,15 @@ class PygameUserInput:
41
43
  ):
42
44
  self._last_keys: Dict[K, bool] = {}
43
45
  self._new_keys: Dict[K, bool] = {but: False for but in BUTTONS}
44
- self._left_finger_tap_pos: pygame.Vector2 = pygame.Vector2(0, 0)
45
- self._right_finger_tap_pos: pygame.Vector2 = pygame.Vector2(0, 0)
46
- self._left_finger_pos: pygame.Vector2 = pygame.Vector2(0, 0)
47
- self._right_finger_pos: pygame.Vector2 = pygame.Vector2(0, 0)
48
- self._last_left_tap: float = 0.0
49
- self._last_right_tap: float = 0.0
50
- self._last_left_motion: float = 0.0
51
- self._last_right_motion: float = 0.0
46
+ self._touch_control = TouchControlSchemeB()
47
+ # self._left_finger_tap_pos: pygame.Vector2 = pygame.Vector2(0, 0)
48
+ # self._right_finger_tap_pos: pygame.Vector2 = pygame.Vector2(0, 0)
49
+ # self._left_finger_pos: pygame.Vector2 = pygame.Vector2(0, 0)
50
+ # self._right_finger_pos: pygame.Vector2 = pygame.Vector2(0, 0)
51
+ # self._last_left_tap: float = 0.0
52
+ # self._last_right_tap: float = 0.0
53
+ # self._last_left_motion: float = 0.0
54
+ # self._last_right_motion: float = 0.0
52
55
  self._key_map: Dict[K, List[int]] = {}
53
56
  self.joystick_to_player: Dict[int, Player] = (
54
57
  joy_to_player
@@ -104,6 +107,7 @@ class PygameUserInput:
104
107
  self._past_events = {}
105
108
  self._new_events = {}
106
109
  self._collect_all_events = False
110
+ self.enable_touch_controls = False
107
111
 
108
112
  def reset(self):
109
113
  self._last_keys = self._new_keys.copy()
@@ -159,7 +163,8 @@ class PygameUserInput:
159
163
  if event.type in JOYSTICK_EVENTS and self.joystick_input_enabled:
160
164
  self._handle_joystick(event)
161
165
 
162
- if event.type in TOUCH_EVENTS:
166
+ # self._touch_control.update(self.width, self.height)
167
+ if self.enable_touch_controls and event.type in TOUCH_EVENTS:
163
168
  self._handle_touch(event)
164
169
 
165
170
  # print(
@@ -270,194 +275,202 @@ class PygameUserInput:
270
275
  self.unset_key(self._js_real(event.joy, K.DOWN))
271
276
 
272
277
  def _handle_touch(self, event):
273
- finger_pos = pygame.Vector2(
274
- event.x * self.width, event.y * self.height
278
+ set_keys, unset_keys = self._touch_control.handle_touch(
279
+ event, self.width, self.height
275
280
  )
281
+ for key in unset_keys:
282
+ self.unset_key(key)
283
+ for key in set_keys:
284
+ self.set_key(key)
276
285
 
277
- if event.type == pygame.FINGERDOWN:
278
- tap = time.time()
279
- for key, area in DEFAULT_TOUCHSCREEN_MAP.items():
286
+ # finger_pos = pygame.Vector2(
287
+ # event.x * self.width, event.y * self.height
288
+ # )
280
289
 
281
- if (
282
- area[0][0] <= event.x < area[1][0]
283
- and area[0][1] <= event.y < area[1][1]
284
- ):
285
- if key == K.P1_UP:
286
- self._left_finger_tap_pos = finger_pos
287
- if tap - self._last_left_tap < DOUBLE_TAP_SPEED:
288
- # print("Left Double Tap")
289
- self.set_key(K.P1_SELECT)
290
- self._last_left_tap = tap
291
- elif key == K.P1_L:
292
- self.set_key(K.P1_L)
293
- else:
294
- self.set_key(key)
295
- self._right_finger_tap_pos = finger_pos
296
- self._last_right_tap = tap
297
-
298
- # if event.x < 0.0625 and event.y < 0.1111:
299
- # self.set_key(K.L)
300
- # elif event.x > 1.0 - 0.0625 and event.y < 0.1111:
301
- # self.set_key(K.R)
302
- # elif event.x < 0.5:
303
- # # print(f"Left Finger Down: {finger_pos}")
304
- # self._left_finger_tap_pos = finger_pos
305
-
306
- # if tap - self._last_left_tap < DOUBLE_TAP_SPEED:
307
- # # print("Left Double Tap")
308
- # self.set_key(K.SELECT)
309
- # self._last_left_tap = tap
310
- # # self._left_finger_pos.x = event.x
311
- # # self._left_finger_pos.y = event.y
312
-
313
- # # if tap - self._last_left_tap < 0.2:
314
- # # print("Left Double Tap")
315
- # # # self._set_key(K.START)
316
- # # # self._unset_key(K.RIGHT)
317
- # # # self._unset_key(K.LEFT)
318
- # # # self._unset_key(K.UP)
319
- # # # self._unset_key(K.DOWN)
320
- # else:
321
- # self._right_finger_tap_pos = finger_pos
322
-
323
- # # if tap - self._last_right_tap < DOUBLE_TAP_SPEED:
324
- # # # print("Right Double Tap")
325
- # # self.set_key(K.SELECT)
326
- # self._last_right_tap = tap
327
- # if event.y < 0.3:
328
- # self.set_key(K.START)
329
- # elif event.x < 0.75:
330
- # self.set_key(K.B)
331
- # else:
332
- # self.set_key(K.A)
333
- # self._right_finger_pos.x = event.x
334
- # self._right_finger_pos.y = event.y
335
- # if tap - self._last_right_tap < 0.2:
336
- # print("Right Double Tap")
337
-
338
- if event.type == pygame.FINGERUP:
339
- # release = time.time()
340
- # finger_dist = (finger_pos - self._left_finger_tap_pos).length()
341
-
342
- if event.x < 0.5:
343
- # print(f"Left Finger Up: {finger_pos}")
344
- # if (
345
- # SINGLE_TAP_MIN
346
- # < release - self._last_left_tap
347
- # < SINGLE_TAP_MAX
348
- # ) and finger_dist < 2.5:
349
- # print("Left Single Tap")
350
- # # self.set_key(K.START)
351
-
352
- self.unset_key(K.P1_SELECT)
353
- self.unset_key(K.P1_RIGHT)
354
- self.unset_key(K.P1_LEFT)
355
- self.unset_key(K.P1_UP)
356
- self.unset_key(K.P1_DOWN)
357
- self.unset_key(K.P1_L)
358
- # print(
359
- # f"Left Finger moved {finger_dist} "
360
- # f"({release - self._last_left_tap} s)"
361
- # )
362
- else:
363
- self.unset_key(K.P1_START)
364
- self.unset_key(K.P1_A)
365
- self.unset_key(K.P1_B)
366
- self.unset_key(K.P1_Y)
367
- self.unset_key(K.P1_X)
368
- self.unset_key(K.P1_R)
369
- # print(f"Right Finger Up: {finger_pos}")
370
- # if (
371
- # SINGLE_TAP_MIN
372
- # < release - self._last_right_tap
373
- # < SINGLE_TAP_MAX
374
- # ) and finger_dist < 2.5:
375
- # print("Right Single Tap")
376
-
377
- # print(
378
- # f"Left Finger moved {finger_dist} "
379
- # f"({release - self._last_left_tap} s)"
380
- # )
381
- #
382
- # if event.x < 0.5:
383
- # if 0.1 < release - self._last_left_tap < 0.25:
384
- # print("Left Single Tap")
385
-
386
- # self._left_finger_pos.x = 0
387
- # self._left_finger_pos.y = 0
388
- # self._unset_key(K.DOWN)
389
- # self._unset_key(K.LEFT)
390
- # self._unset_key(K.UP)
391
- # self._unset_key(K.RIGHT)
392
- # self._unset_key(K.START)
393
- # else:
394
- # if 0.1 < release - self._last_right_tap < 0.25:
395
- # print("Right Single Tap")
396
-
397
- # self._unset_key(K.A)
398
- # self._unset_key(K.B)
399
- if event.type == pygame.FINGERMOTION:
400
- if event.x < 0.5:
401
- vd = finger_pos - self._left_finger_tap_pos
402
- self.unset_key(K.P1_RIGHT)
403
- self.unset_key(K.P1_LEFT)
404
- self.unset_key(K.P1_UP)
405
- self.unset_key(K.P1_DOWN)
406
- if abs(vd.x) > 2 * abs(vd.y):
407
- # Horizontal
408
- if vd.x > 5.0:
409
- self.set_key(K.P1_RIGHT)
410
- self.unset_key(K.P1_LEFT)
411
- self.unset_key(K.P1_UP)
412
- self.unset_key(K.P1_DOWN)
413
- elif vd.x < -5.0:
414
- self.set_key(K.P1_LEFT)
415
- self.unset_key(K.P1_RIGHT)
416
- self.unset_key(K.P1_UP)
417
- self.unset_key(K.P1_DOWN)
418
- elif abs(vd.x) * 2 < abs(vd.y):
419
- # Vertical
420
- if vd.y > 5.0:
421
- self.unset_key(K.P1_RIGHT)
422
- self.unset_key(K.P1_LEFT)
423
- self.unset_key(K.P1_UP)
424
- self.set_key(K.P1_DOWN)
425
- elif vd.y < -5.0:
426
- self.unset_key(K.P1_LEFT)
427
- self.unset_key(K.P1_RIGHT)
428
- self.set_key(K.P1_UP)
429
- self.unset_key(K.P1_DOWN)
430
- elif abs(vd.x) * 1.05 > abs(vd.y) or abs(vd.x) < 1.05 * abs(
431
- vd.y
432
- ):
433
- if vd.x < 0:
434
- self.set_key(K.P1_LEFT)
435
- elif vd.x > 0:
436
- self.set_key(K.P1_RIGHT)
437
- if vd.y < 0:
438
- self.set_key(K.P1_UP)
439
- elif vd.y > 0:
440
- self.set_key(K.P1_DOWN)
441
- # else:
442
- # vd = finger_pos - self._right_finger_tap_pos
443
- # self.unset_key(K.A)
444
- # self.unset_key(K.B)
445
- # self.unset_key(K.Y)
446
- # self.unset_key(K.X)
447
- # if abs(vd.x) > 2 * abs(vd.y):
448
- # # Horizontal
449
- # if vd.x > 5.0:
450
- # self.set_key(K.Y)
451
- # elif vd.x < -5.0:
452
- # self.set_key(K.B)
453
- # elif abs(vd.x) * 2 < abs(vd.y):
454
- # # Vertical
455
- # if vd.y > 5.0:
456
- # self.set_key(K.A)
457
- # elif vd.y < -5.0:
458
- # self.set_key(K.X)
459
-
460
- self.vd = vd
290
+ # if event.type == pygame.FINGERDOWN:
291
+ # tap = time.time()
292
+ # for key, area in DEFAULT_TOUCHSCREEN_MAP.items():
293
+
294
+ # if (
295
+ # area[0][0] <= event.x < area[1][0]
296
+ # and area[0][1] <= event.y < area[1][1]
297
+ # ):
298
+ # if key == K.P1_UP:
299
+ # self._left_finger_tap_pos = finger_pos
300
+ # if tap - self._last_left_tap < DOUBLE_TAP_SPEED:
301
+ # # print("Left Double Tap")
302
+ # self.set_key(K.P1_SELECT)
303
+ # self._last_left_tap = tap
304
+ # elif key == K.P1_L:
305
+ # self.set_key(K.P1_L)
306
+ # else:
307
+ # self.set_key(key)
308
+ # self._right_finger_tap_pos = finger_pos
309
+ # self._last_right_tap = tap
310
+
311
+ # # if event.x < 0.0625 and event.y < 0.1111:
312
+ # # self.set_key(K.L)
313
+ # # elif event.x > 1.0 - 0.0625 and event.y < 0.1111:
314
+ # # self.set_key(K.R)
315
+ # # elif event.x < 0.5:
316
+ # # # print(f"Left Finger Down: {finger_pos}")
317
+ # # self._left_finger_tap_pos = finger_pos
318
+
319
+ # # if tap - self._last_left_tap < DOUBLE_TAP_SPEED:
320
+ # # # print("Left Double Tap")
321
+ # # self.set_key(K.SELECT)
322
+ # # self._last_left_tap = tap
323
+ # # # self._left_finger_pos.x = event.x
324
+ # # # self._left_finger_pos.y = event.y
325
+
326
+ # # # if tap - self._last_left_tap < 0.2:
327
+ # # # print("Left Double Tap")
328
+ # # # # self._set_key(K.START)
329
+ # # # # self._unset_key(K.RIGHT)
330
+ # # # # self._unset_key(K.LEFT)
331
+ # # # # self._unset_key(K.UP)
332
+ # # # # self._unset_key(K.DOWN)
333
+ # # else:
334
+ # # self._right_finger_tap_pos = finger_pos
335
+
336
+ # # # if tap - self._last_right_tap < DOUBLE_TAP_SPEED:
337
+ # # # # print("Right Double Tap")
338
+ # # # self.set_key(K.SELECT)
339
+ # # self._last_right_tap = tap
340
+ # # if event.y < 0.3:
341
+ # # self.set_key(K.START)
342
+ # # elif event.x < 0.75:
343
+ # # self.set_key(K.B)
344
+ # # else:
345
+ # # self.set_key(K.A)
346
+ # # self._right_finger_pos.x = event.x
347
+ # # self._right_finger_pos.y = event.y
348
+ # # if tap - self._last_right_tap < 0.2:
349
+ # # print("Right Double Tap")
350
+
351
+ # if event.type == pygame.FINGERUP:
352
+ # # release = time.time()
353
+ # # finger_dist = (finger_pos - self._left_finger_tap_pos).length()
354
+
355
+ # if event.x < 0.5:
356
+ # # print(f"Left Finger Up: {finger_pos}")
357
+ # # if (
358
+ # # SINGLE_TAP_MIN
359
+ # # < release - self._last_left_tap
360
+ # # < SINGLE_TAP_MAX
361
+ # # ) and finger_dist < 2.5:
362
+ # # print("Left Single Tap")
363
+ # # # self.set_key(K.START)
364
+
365
+ # self.unset_key(K.P1_SELECT)
366
+ # self.unset_key(K.P1_RIGHT)
367
+ # self.unset_key(K.P1_LEFT)
368
+ # self.unset_key(K.P1_UP)
369
+ # self.unset_key(K.P1_DOWN)
370
+ # self.unset_key(K.P1_L)
371
+ # # print(
372
+ # # f"Left Finger moved {finger_dist} "
373
+ # # f"({release - self._last_left_tap} s)"
374
+ # # )
375
+ # else:
376
+ # self.unset_key(K.P1_START)
377
+ # self.unset_key(K.P1_A)
378
+ # self.unset_key(K.P1_B)
379
+ # self.unset_key(K.P1_Y)
380
+ # self.unset_key(K.P1_X)
381
+ # self.unset_key(K.P1_R)
382
+ # # print(f"Right Finger Up: {finger_pos}")
383
+ # # if (
384
+ # # SINGLE_TAP_MIN
385
+ # # < release - self._last_right_tap
386
+ # # < SINGLE_TAP_MAX
387
+ # # ) and finger_dist < 2.5:
388
+ # # print("Right Single Tap")
389
+
390
+ # # print(
391
+ # # f"Left Finger moved {finger_dist} "
392
+ # # f"({release - self._last_left_tap} s)"
393
+ # # )
394
+ # #
395
+ # # if event.x < 0.5:
396
+ # # if 0.1 < release - self._last_left_tap < 0.25:
397
+ # # print("Left Single Tap")
398
+
399
+ # # self._left_finger_pos.x = 0
400
+ # # self._left_finger_pos.y = 0
401
+ # # self._unset_key(K.DOWN)
402
+ # # self._unset_key(K.LEFT)
403
+ # # self._unset_key(K.UP)
404
+ # # self._unset_key(K.RIGHT)
405
+ # # self._unset_key(K.START)
406
+ # # else:
407
+ # # if 0.1 < release - self._last_right_tap < 0.25:
408
+ # # print("Right Single Tap")
409
+
410
+ # # self._unset_key(K.A)
411
+ # # self._unset_key(K.B)
412
+ # if event.type == pygame.FINGERMOTION:
413
+ # if event.x < 0.5:
414
+ # vd = finger_pos - self._left_finger_tap_pos
415
+ # self.unset_key(K.P1_RIGHT)
416
+ # self.unset_key(K.P1_LEFT)
417
+ # self.unset_key(K.P1_UP)
418
+ # self.unset_key(K.P1_DOWN)
419
+ # if abs(vd.x) > 2 * abs(vd.y):
420
+ # # Horizontal
421
+ # if vd.x > 5.0:
422
+ # self.set_key(K.P1_RIGHT)
423
+ # self.unset_key(K.P1_LEFT)
424
+ # self.unset_key(K.P1_UP)
425
+ # self.unset_key(K.P1_DOWN)
426
+ # elif vd.x < -5.0:
427
+ # self.set_key(K.P1_LEFT)
428
+ # self.unset_key(K.P1_RIGHT)
429
+ # self.unset_key(K.P1_UP)
430
+ # self.unset_key(K.P1_DOWN)
431
+ # elif abs(vd.x) * 2 < abs(vd.y):
432
+ # # Vertical
433
+ # if vd.y > 5.0:
434
+ # self.unset_key(K.P1_RIGHT)
435
+ # self.unset_key(K.P1_LEFT)
436
+ # self.unset_key(K.P1_UP)
437
+ # self.set_key(K.P1_DOWN)
438
+ # elif vd.y < -5.0:
439
+ # self.unset_key(K.P1_LEFT)
440
+ # self.unset_key(K.P1_RIGHT)
441
+ # self.set_key(K.P1_UP)
442
+ # self.unset_key(K.P1_DOWN)
443
+ # elif abs(vd.x) * 1.05 > abs(vd.y) or abs(vd.x) < 1.05 * abs(
444
+ # vd.y
445
+ # ):
446
+ # if vd.x < 0:
447
+ # self.set_key(K.P1_LEFT)
448
+ # elif vd.x > 0:
449
+ # self.set_key(K.P1_RIGHT)
450
+ # if vd.y < 0:
451
+ # self.set_key(K.P1_UP)
452
+ # elif vd.y > 0:
453
+ # self.set_key(K.P1_DOWN)
454
+ # # else:
455
+ # # vd = finger_pos - self._right_finger_tap_pos
456
+ # # self.unset_key(K.A)
457
+ # # self.unset_key(K.B)
458
+ # # self.unset_key(K.Y)
459
+ # # self.unset_key(K.X)
460
+ # # if abs(vd.x) > 2 * abs(vd.y):
461
+ # # # Horizontal
462
+ # # if vd.x > 5.0:
463
+ # # self.set_key(K.Y)
464
+ # # elif vd.x < -5.0:
465
+ # # self.set_key(K.B)
466
+ # # elif abs(vd.x) * 2 < abs(vd.y):
467
+ # # # Vertical
468
+ # # if vd.y > 5.0:
469
+ # # self.set_key(K.A)
470
+ # # elif vd.y < -5.0:
471
+ # # self.set_key(K.X)
472
+
473
+ # self.vd = vd
461
474
 
462
475
  def _handle_mouse(self, event):
463
476
  # if event.type == pygame.MOUSEBUTTONDOWN:
@@ -674,6 +687,9 @@ class PygameUserInput:
674
687
  def trigger_all_events_collection(self, active: bool = True):
675
688
  self._collect_all_events = active
676
689
 
690
+ def get_touch_state(self):
691
+ return self._touch_control.get_touch_state()
692
+
677
693
 
678
694
  def _button_to_player(button: K, player: Player):
679
695
  return K(button.value + 12 * player.value)
mima/backend/touch_control_scheme_a.py ADDED
@@ -0,0 +1,126 @@
1
+ import time
2
+
3
+ import pygame
4
+
5
+ from ..types.keys import Key as K
6
+ from ..util.constants import DOUBLE_TAP_SPEED
7
+ from ..util.input_defaults import BUTTONS, DEFAULT_TOUCHSCREEN_MAP
8
+
9
+
10
+ class TouchControlSchemeA:
11
+
12
+ def __init__(self):
13
+
14
+ self._left_finger_tap_pos = 0.0
15
+ self._right_finger_tap_pos = 0.0
16
+
17
+ self._last_left_tap = 0.0
18
+ self._last_right_tap = 0.0
19
+
20
+ def handle_touch(self, event, width=1.0, height=1.0):
21
+ set_keys = []
22
+ unset_keys = []
23
+
24
+ tap_pos = pygame.Vector2(event.x * width, event.y * height)
25
+
26
+ if event.type == pygame.FINGERDOWN:
27
+ tap_time = time.time()
28
+ for key, area in DEFAULT_TOUCHSCREEN_MAP.items():
29
+
30
+ if (
31
+ area[0][0] <= event.x < area[1][0]
32
+ and area[0][1] <= event.y < area[1][1]
33
+ ):
34
+ if key == K.P1_UP:
35
+ self._left_finger_tap_pos = tap_pos
36
+ if tap_time - self._last_left_tap < DOUBLE_TAP_SPEED:
37
+ # print("Left Double Tap")
38
+ set_keys.append(K.P1_SELECT)
39
+ self._last_left_tap = tap_time
40
+ elif key == K.P1_L:
41
+ set_keys.append(K.P1_L)
42
+ else:
43
+ set_keys.append(key)
44
+ self._right_finger_tap_pos = tap_pos
45
+ self._last_right_tap = tap_time
46
+
47
+ if event.type == pygame.FINGERUP:
48
+ # release = time.time()
49
+ # finger_dist = (finger_pos - self._left_finger_tap_pos).length()
50
+
51
+ if event.x < 0.5:
52
+ # print(f"Left Finger Up: {finger_pos}")
53
+ # if (
54
+ # SINGLE_TAP_MIN
55
+ # < release - self._last_left_tap
56
+ # < SINGLE_TAP_MAX
57
+ # ) and finger_dist < 2.5:
58
+ # print("Left Single Tap")
59
+ # # set_keys.append(K.START)
60
+
61
+ unset_keys.append(K.P1_SELECT)
62
+ unset_keys.append(K.P1_RIGHT)
63
+ unset_keys.append(K.P1_LEFT)
64
+ unset_keys.append(K.P1_UP)
65
+ unset_keys.append(K.P1_DOWN)
66
+ unset_keys.append(K.P1_L)
67
+ # print(
68
+ # f"Left Finger moved {finger_dist} "
69
+ # f"({release - self._last_left_tap} s)"
70
+ # )
71
+ else:
72
+ unset_keys.append(K.P1_START)
73
+ unset_keys.append(K.P1_A)
74
+ unset_keys.append(K.P1_B)
75
+ unset_keys.append(K.P1_Y)
76
+ unset_keys.append(K.P1_X)
77
+ unset_keys.append(K.P1_R)
78
+
79
+ if event.type == pygame.FINGERMOTION:
80
+ if event.x < 0.5:
81
+ vd = tap_pos - self._left_finger_tap_pos
82
+ unset_keys.append(K.P1_RIGHT)
83
+ unset_keys.append(K.P1_LEFT)
84
+ unset_keys.append(K.P1_UP)
85
+ unset_keys.append(K.P1_DOWN)
86
+ if abs(vd.x) > 2 * abs(vd.y):
87
+ # Horizontal
88
+ if vd.x > 5.0:
89
+ set_keys.append(K.P1_RIGHT)
90
+ unset_keys.append(K.P1_LEFT)
91
+ unset_keys.append(K.P1_UP)
92
+ unset_keys.append(K.P1_DOWN)
93
+ elif vd.x < -5.0:
94
+ set_keys.append(K.P1_LEFT)
95
+ unset_keys.append(K.P1_RIGHT)
96
+ unset_keys.append(K.P1_UP)
97
+ unset_keys.append(K.P1_DOWN)
98
+ elif abs(vd.x) * 2 < abs(vd.y):
99
+ # Vertical
100
+ if vd.y > 5.0:
101
+ unset_keys.append(K.P1_RIGHT)
102
+ unset_keys.append(K.P1_LEFT)
103
+ unset_keys.append(K.P1_UP)
104
+ set_keys.append(K.P1_DOWN)
105
+ elif vd.y < -5.0:
106
+ unset_keys.append(K.P1_LEFT)
107
+ unset_keys.append(K.P1_RIGHT)
108
+ set_keys.append(K.P1_UP)
109
+ unset_keys.append(K.P1_DOWN)
110
+ elif abs(vd.x) * 1.05 > abs(vd.y) or abs(vd.x) < 1.05 * abs(
111
+ vd.y
112
+ ):
113
+ if vd.x < 0:
114
+ set_keys.append(K.P1_LEFT)
115
+ elif vd.x > 0:
116
+ set_keys.append(K.P1_RIGHT)
117
+ if vd.y < 0:
118
+ set_keys.append(K.P1_UP)
119
+ elif vd.y > 0:
120
+ set_keys.append(K.P1_DOWN)
121
+ self.vd = vd
122
+
123
+ return set_keys, unset_keys
124
+
125
+ def get_touch_state(self):
126
+ return {}