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

mima/backend/touch_control_scheme_b.py

@@ -0,0 +1,132 @@
+import time
+
+import pygame
+
+from ..types.keys import Key as K
+from ..util.constants import DOUBLE_TAP_SPEED
+from ..util.input_defaults import ALT_TOUCHSCREEN_MAP, BUTTONS
+
+
+class TouchControlSchemeB:
+
+    def __init__(self):
+
+        self.move_start_pos = pygame.Vector2()
+        self.move_pos = pygame.Vector2()
+        self.move_sy = 0.0
+        self.move_px = 0.0
+        self.move_py = 0.0
+        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
+        self._keys_active = {k: False for k in K}
+        self._state = {}
+        for key, conf in ALT_TOUCHSCREEN_MAP.items():
+            px, py = conf["pos"]
+            w, h = conf["size"]
+            self._state[key] = {
+                "rpx": px,
+                "rpy": py,
+                "rwidth": w,
+                "rheight": h,
+                "active": False,
+            }
+
+    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)
+        keys_active = {k: False for k in K}
+        # print(f"{event.x:.2f}, {event.y:.2f}", end="")
+        for key, conf in ALT_TOUCHSCREEN_MAP.items():
+            px, py = conf["pos"]
+            w, h = conf["size"]
+            area = [[px, py], [px + w, py + h]]
+
+            if (
+                area[0][0] <= event.x < area[1][0]
+                and area[0][1] <= event.y < area[1][1]
+            ):
+                if key == K.P1_UP:
+                    if event.type == pygame.FINGERDOWN:
+                        self.move_start_pos = pygame.Vector2(tap_pos)
+                        self.move_pos = pygame.Vector2(tap_pos)
+                        self._state[key]["rsx"] = event.x
+                        self._state[key]["rsy"] = event.y
+                        self._state[key]["rpx"] = event.x
+                        self._state[key]["rpy"] = event.y
+                    elif event.type == pygame.FINGERMOTION:
+                        self.move_pos = tap_pos
+                        self._state[key]["rpx"] = event.x
+                        self._state[key]["rpy"] = event.y
+
+                        vd = self.move_pos - self.move_start_pos
+                        if abs(vd.x) > 2 * abs(vd.y):
+                            # Horizontal
+                            if vd.x > 5.0:
+                                keys_active[K.P1_RIGHT] = True
+                                # print("..>", end="")
+                            elif vd.x < -5.0:
+                                keys_active[K.P1_LEFT] = True
+                                # print("..<", end="")
+                        elif abs(vd.x) * 2 < abs(vd.y):
+                            # Vertical
+                            if vd.y > 5.0:
+                                keys_active[K.P1_DOWN] = True
+                                # print("..v", end="")
+                            elif vd.y < -5.0:
+                                keys_active[K.P1_UP] = True
+                                # print("..^", end="")
+                        elif abs(vd.x) * 1.05 > abs(vd.y) or abs(
+                            vd.x
+                        ) < 1.05 * abs(vd.y):
+                            # Diagonal
+                            if vd.x < 0:
+                                keys_active[K.P1_LEFT] = True
+                                # print("..<", end="")
+                            elif vd.x > 0:
+                                keys_active[K.P1_RIGHT] = True
+                                # print("..>", end="")
+                            if vd.y < 0:
+                                keys_active[K.P1_UP] = True
+                                # print("..^", end="")
+                            elif vd.y > 0:
+                                keys_active[K.P1_DOWN] = True
+                                # print("..v", end="")
+                    # elif event.type == pygame.FINGERUP:
+                    #     unset_keys.append(K.P1_RIGHT)
+                    #     unset_keys.append(K.P1_LEFT)
+                    #     unset_keys.append(K.P1_UP)
+                    #     unset_keys.append(K.P1_DOWN)
+                else:
+                    if event.type == pygame.FINGERDOWN:
+                        keys_active[key] = True
+                        # print(f"..{key.name}", end="")
+                    if event.type == pygame.FINGERMOTION:
+                        keys_active[key] = True
+                        # print(f"..{key.name}", end="")
+        # print()
+        for k, val in keys_active.items():
+            if val:
+                set_keys.append(k)
+                # self._state.setdefault(k, {})["active"] = True
+                if k in self._state:
+                    self._state[k]["active"] = True
+                if k in [K.P1_LEFT, K.P1_RIGHT, K.P1_DOWN]:
+                    self._state[K.P1_UP]["active"] = True
+            else:
+                unset_keys.append(k)
+                if k in self._state:
+                    self._state[k]["active"] = False
+        return set_keys, unset_keys
+
+    def get_touch_state(self):
+        state = {}
+        for key, conf in self._state.items():
+            nkey = K(key.value - 12)
+            state[nkey] = conf
+
+        return state

mima/core/collision.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import math
+from itertools import product
 from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Tuple
 
 from ..maps.tilemap import Tilemap
@@ -35,7 +36,9 @@ def check_object_to_map_collision(
 
     collided_with_map = False
     if obj.solid_vs_map:
-        if collision_with_map(tilemap, left, right, top, bottom, layer, collision):
+        if collision_with_map(
+            tilemap, left, right, top, bottom, layer, collision
+        ):
             # On rare occasions, the object might be pushed towards
             # the wall, i.e. old and new pos are equal
             # Decide depending on the decimal part of the position
@@ -66,7 +69,9 @@ def check_object_to_map_collision(
         top = new_py + obj.hitbox_py
         bottom = top + obj.hitbox_height
 
-        if collision_with_map(tilemap, left, right, top, bottom, layer, collision):
+        if collision_with_map(
+            tilemap, left, right, top, bottom, layer, collision
+        ):
             # See comment above
             if new_py == obj.py:
                 decimal_dif = new_py - int(new_py)
@@ -244,34 +249,50 @@ def add_to_collision_chunk(
     #         collision_chunks[chidx].insert(0, obj)
     #     else:
     #         collision_chunks[chidx].append(obj)
-
-    chid = _test_chunk_position(
-        collision_chunks, obj, obj.px, obj.py, chunk_size, chunks_per_row
-    )
-    chid_right = _test_chunk_position(
-        collision_chunks, obj, obj.px + 1, obj.py, chunk_size, chunks_per_row
-    )
-
-    chid_bottom = _test_chunk_position(
-        collision_chunks, obj, obj.px, obj.py + 1, chunk_size, chunks_per_row
-    )
-
-    chunk_ids.append(chid)
-    if chid != chid_right:
-        chunk_ids.append(chid_right)
-    if chid != chid_bottom:
-        chunk_ids.append(chid_bottom)
-    if chid != chid_right and chid != chid_bottom:
+    centerx = obj.px + (obj.hitbox_px + obj.hitbox_width) / 2
+    centery = obj.py + (obj.hitbox_py + obj.hitbox_height) / 2
+    # chid = _test_chunk_position(
+    #     collision_chunks, obj, centerx, centery, chunk_size, chunks_per_row
+    # )
+    offsets = [[0, 0]] + [
+        list(p) for p in product([-1, 0, 1], repeat=2) if p != (0, 0)
+    ]
+    for x, y in offsets:
         chunk_ids.append(
             _test_chunk_position(
                 collision_chunks,
                 obj,
-                obj.px + 1,
-                obj.py + 1,
+                centerx + x,
+                centery + y,
                 chunk_size,
                 chunks_per_row,
             )
         )
+    chunk_ids = list(dict.fromkeys(chunk_ids))
+    # chid_right = _test_chunk_position(
+    #     collision_chunks, obj, obj.px + 1, obj.py, chunk_size, chunks_per_row
+    # )
+
+    # chid_bottom = _test_chunk_position(
+    #     collision_chunks, obj, obj.px, obj.py + 1, chunk_size, chunks_per_row
+    # )
+
+    # chunk_ids.append(chid)
+    # if chid != chid_right:
+    #     chunk_ids.append(chid_right)
+    # if chid != chid_bottom:
+    #     chunk_ids.append(chid_bottom)
+    # if chid != chid_right and chid != chid_bottom:
+    #     chunk_ids.append(
+    #         _test_chunk_position(
+    #             collision_chunks,
+    #             obj,
+    #             obj.px + 1,
+    #             obj.py + 1,
+    #             chunk_size,
+    #             chunks_per_row,
+    #         )
+    #     )
 
     for chid in obj.chunks:
         if (
@@ -283,7 +304,9 @@ def add_to_collision_chunk(
     return chunk_ids
 
 
-def _test_chunk_position(collision_chunks, obj, px, py, chunk_size, chunks_per_row):
+def _test_chunk_position(
+    collision_chunks, obj, px, py, chunk_size, chunks_per_row
+):
     chidx = _chunk_index(px, py, chunk_size, chunks_per_row)
     collision_chunks.setdefault(chidx, [])
 

mima/core/engine.py

@@ -26,13 +26,9 @@ from ..usables.weapon import Weapon
 from ..util import RuntimeConfig
 from ..util.logging import install_trace_logger
 from ..view.camera import Camera
-
-# from .view.game_mode import GameMode
 from ..view.mima_view import MimaView
 from .database import Database
 
-# from .view.scene import Scene
-
 if TYPE_CHECKING:
     from .states.game_state import GameState
 
@@ -51,7 +47,9 @@ class MimaEngine(ABC):
         self.rtc = RuntimeConfig(config_path, default_config)
         install_trace_logger()
 
-        self.backend: PygameBackend = PygameBackend(self.rtc, init_file, platform)
+        self.backend: PygameBackend = PygameBackend(
+            self.rtc, init_file, platform
+        )
         self.db: Database
         self._caption: str = caption
         self.seconds_total: float = 0.0
@@ -60,6 +58,9 @@ class MimaEngine(ABC):
         self.elapsed_time: float = 0.00022
         self._app_time: float = 0.0
 
+        self.enable_touch_controls: bool = False
+        self.show_touch_controls: bool = False
+
         self.mode: Mode = Mode.LOADING
         self.gate_color: GateColor = GateColor.RED
         self.n_gate_colors = 2
@@ -67,9 +68,6 @@ class MimaEngine(ABC):
         self.memory: Memory = Memory()
         self.all_games: Dict[str, GameState] = {}
         self.current_game: str = ""
-        # self.player: Creature
-        # self.quests: List[Quest] = []
-        # self._items: Dict[str, Item] = {}
         self.cameras: List[str] = []
 
     def construct(
@@ -110,6 +108,9 @@ class MimaEngine(ABC):
         self.backend.construct(
             width, height, pixel_size, fullscreen, target_fps, resizable
         )
+        self.backend.user_input.enable_touch_controls = (
+            self.enable_touch_controls
+        )
 
         return True
 
@@ -126,7 +127,8 @@ class MimaEngine(ABC):
         if self.on_user_create():
             while self.backend.keep_running():
                 self.backend.set_caption(
-                    f"{self._caption} ({self.game_fps:.2f}/" f"{self.app_fps:.2f} fps)"
+                    f"{self._caption} ({self.game_fps:.2f}/"
+                    f"{self.app_fps:.2f} fps)"
                 )
                 self.backend.process_events()
 
@@ -160,7 +162,10 @@ class MimaEngine(ABC):
                     app_frames = 0
                     app_seconds -= 1.0
 
-            print(f"App/Game Frames total: {app_frames_total}/" f"{game_frames_total}")
+            print(
+                f"App/Game Frames total: {app_frames_total}/"
+                f"{game_frames_total}"
+            )
             print(f"Seconds total: {self.seconds_total:.3f}")
             print(
                 "Average App/Game FPS: "
@@ -276,7 +281,9 @@ class MimaEngine(ABC):
     def set_player(self, creature: Creature, player: Player = Player.P1):
         self.memory.player[player] = creature
 
-    def trigger_teleport(self, active: bool = True, player: Player = Player.P1):
+    def trigger_teleport(
+        self, active: bool = True, player: Player = Player.P1
+    ):
         self.memory.teleport_active[player] = active
 
     def is_teleport_active(self, player: Player = Player.P1):
@@ -288,7 +295,9 @@ class MimaEngine(ABC):
     def is_dialog_active(self, player: Player = Player.P1):
         return self.memory.dialog_active[player]
 
-    def trigger_script(self, active: bool = True, player: Player = Player.P1) -> None:
+    def trigger_script(
+        self, active: bool = True, player: Player = Player.P1
+    ) -> None:
         self.memory.script_active[player] = active
 
     def is_script_active(self, player: Player = Player.P1) -> bool:
@@ -337,7 +346,10 @@ class MimaEngine(ABC):
 
     @dialog_active.setter
     def dialog_active(self, val):
-        print("dialog_active is deprecated; use " "'trigger_dialog(active)' instead.")
+        print(
+            "dialog_active is deprecated; use "
+            "'trigger_dialog(active)' instead."
+        )
         self.memory.dialog_active = val
 
     @property

mima/core/mode_engine.py

@@ -22,7 +22,9 @@ class MimaModeEngine(MimaEngine):
         platform="PC",
         caption: str = "MimaEngine",
     ):
-        super().__init__(init_file, config_path, default_config, platform, caption)
+        super().__init__(
+            init_file, config_path, default_config, platform, caption
+        )
 
         self.modes: Dict[Mode, MimaMode] = {}
         self.mode: Optional[MimaMode] = None
@@ -31,6 +33,7 @@ class MimaModeEngine(MimaEngine):
 
         self.draw_chunks: bool = False
         self.draw_chunk_info: bool = False
+        self.draw_dyn_ids: bool = False
         self.disable_filter: bool = False
         self._timer = 1.0
 
@@ -67,7 +70,9 @@ class MimaModeEngine(MimaEngine):
         self.mode.load()
 
     def return_mode(self):
-        LOG.debug("Returning to previous mode. Stack: %s", str(self.mode_stack))
+        LOG.debug(
+            "Returning to previous mode. Stack: %s", str(self.mode_stack)
+        )
         self.mode_stack.pop()
         self.mode = self.modes[self.mode_stack[-1]]
         self.mode.load()

mima/objects/creature.py

@@ -298,6 +298,12 @@ class Creature(Dynamic):
 
         self.projectiles = []
 
+    def on_enter_map(self):
+        pass
+
+    def on_exit_map(self):
+        pass
+
     def on_death(self):
         if self.spawn_on_death:
             for do in self.spawn_on_death:

mima/objects/effects/debug_box.py

@@ -21,7 +21,12 @@ class DynamicDebugBox(Projectile):
         ids=None,
     ) -> None:
         super().__init__(
-            0, 0, 0, 0, 0, Alignment.NEUTRAL, follow.tilemap, "DynamicDebugBox"
+            0,
+            0,
+            "DynamicDebugBox",
+            duration=0.0,
+            alignment=Alignment.NEUTRAL,
+            tilemap=follow.tilemap,
         )
         self.layer = 2
         self.sprite = None
@@ -76,7 +81,11 @@ class DynamicDebugBox(Projectile):
 class StaticDebugBox(Projectile):
     def __init__(self, px, py, width, height, color, n_frames=1, ids=None):
         super().__init__(
-            px, py, 0, 0, 0, Alignment.NEUTRAL, None, "StaticDebugBox"
+            px,
+            py,
+            "StaticDebugBox",
+            duration=0.0,
+            alignment=Alignment.NEUTRAL,
         )
         self.layer = 2
         self._color = color

mima/objects/world/container.py

@@ -138,7 +138,7 @@ class Container(Dynamic):
                         CommandParallel(
                             [
                                 CommandShowDialog(
-                                    [f"You received {self.item_name}"],
+                                    [f"You received {self.item.name}"],
                                 ),
                                 CommandPresentItem(self.item_name, target),
                                 CommandGiveItem(self.item_name, target),

mima/objects/world/oneway.py

@@ -35,6 +35,7 @@ class Oneway(Dynamic):
             dyn_id=dyn_id,
         )
         self.type = ObjectType.ONEWAY
+        self.layer = 0
         self.sprite.width = int(width * self.engine.rtc.tile_width)
         self.sprite.height = int(height * self.engine.rtc.tile_height)
 
@@ -46,24 +47,26 @@ class Oneway(Dynamic):
         self.height: float = height
         self.jump_vx: float = 0.0
         self.jump_vy: float = 0.0
+        self.jump_direction = Direction.from_velocity(jump_vx, jump_vy)
         self.activation_delay: float = ONEWAY_ACTIVATION_DELAY
         self.triggered: bool = False
+        self.is_active: bool = False
         self.cooldown: float = 0.0
         self.target = None
 
         if jump_vx < 0:
             self.jump_vx = jump_vx - 1
-            self.hitbox_px += 0.1
+            # self.hitbox_px += 0.1
         elif jump_vx > 0:
             self.jump_vx = jump_vx + 1
-            self.hitbox_px -= 0.1
+            # self.hitbox_px -= 0.1
 
         if jump_vy < 0:
             self.jump_vy = jump_vy - 1
-            self.hitbox_py += 0.1
+            # self.hitbox_py += 0.1
         elif jump_vy > 0:
             self.jump_vy = jump_vy + 1
-            self.hitbox_py -= 0.1
+            # self.hitbox_py -= 0.1
 
     def update(self, elapsed_time, target=None):
         self.sprite.update(
@@ -90,9 +93,15 @@ class Oneway(Dynamic):
         # Activation countdown reached 0 and the jump is initiated.
         if self.timer <= 0.0 and self.target is not None:
             self.engine.script.add_command(
-                CommandOnewayMove(self.target, self.jump_vx, self.jump_vy)
+                CommandOnewayMove(
+                    self.target,
+                    self.jump_vx,
+                    self.jump_vy,
+                    target.get_player(),
+                )
             )
             self.cooldown = 2.0
+            self.is_active
 
         # Reset the triggered flag so it has to be activated again
         # by interaction
@@ -100,11 +109,25 @@ class Oneway(Dynamic):
         self.target = None
 
     def on_interaction(self, target, nature=Nature.WALK):
-        if target.type == ObjectType.PLAYER and nature == Nature.WALK:
+        if (
+            target.type == ObjectType.PLAYER
+            and nature == Nature.WALK
+            and self.cooldown <= 0.0
+        ):
             # No interaction when target is higher than the oneway
             if target.pz > 0:
                 return False
 
+            if self.jump_direction != target.facing_direction:
+                return False
+
+            tcenterx = target.px + (target.hitbox_px + target.hitbox_width) / 2
+            tbottomy = target.py + target.hitbox_py + target.hitbox_height
+            ttopy = target.py + target.hitbox_py
+            tleftx = target.px + target.hitbox_px
+            trightx = tleftx + target.hitbox_width
+
+            # print(tcenterx, tbottomy)
             # We have to check that target is not placed "more" in the
             # target direction than the oneway
             if (
@@ -119,7 +142,7 @@ class Oneway(Dynamic):
                 and target.py <= self.py + self.height - target.hitbox_py
             ):
                 return False
-            if self.jump_vy > 0 and target.py >= self.py:
+            if self.jump_vy > 0 and tbottomy >= self.py:  # FIXME
                 return False
 
             if self.jump_vx == 0:
@@ -133,12 +156,15 @@ class Oneway(Dynamic):
                     return False
                 if target.py + 1.0 <= self.py:
                     return False
-
             self.triggered = True
             self.target = target
             if self.timer <= 0.0:
                 self.timer = self.activation_delay
+                # return False
 
+            # print(
+            #     f"activated {self.timer:.3f}, {self.px, self.py}, {target.px, target.py}, {target.sprite.width, target.sprite.height}"
+            # )
             return True
 
         return False

mima/objects/world/pickup.py

@@ -39,6 +39,7 @@ class Pickup(Dynamic):
 
         self.collected = False
         self.solid_vs_dyn = False
+        self.moves_on_collision = True
         # self.sprite = AnimatedSprite(
         #     self.item.tileset_name,
         #     self.item.image_name,
@@ -82,6 +83,8 @@ class Pickup(Dynamic):
             return
 
         if self.pz != 0:
+
+            # print("Draw item circle")
             self.engine.backend.fill_circle(
                 (self.px - ox + 0.5) * self.sprite.width,
                 (self.py - oy + 0.7) * self.sprite.height,
@@ -90,7 +93,10 @@ class Pickup(Dynamic):
                 camera_name,
             )
         self.sprite.draw_self(
-            self.px - ox, self.py - oy, camera_name, draw_to_ui=draw_to_ui
+            self.px - ox,
+            self.py - oy - self.pz,
+            camera_name,
+            draw_to_ui=draw_to_ui,
         )
         # self.engine.backend.draw_partial_sprite(
         #     (self.px - ox) * self.item.sprite_width,
@@ -129,7 +135,7 @@ class Pickup(Dynamic):
                 else:
                     eff = WalkingOnWater(self)
                 self.effects.append(eff)
-                self.engine.scene.add_effect(eff)
+                self.engine.get_view().add_effect(eff, self.tilemap.name)
         # else:
         #     self.attributes.speed_mod = 1.0
 

mima/objects/world/switch.py

@@ -46,10 +46,15 @@ class Switch(Dynamic):
         self.listener_ids: List[int] = []
         self.listeners: List[Dynamic] = []
         self.send_initial_signal = initial_signal
+        self.cooldown = 0.0
+        self.cooldown_reset = 0.8
 
         # self._gs_map = {False: GraphicState.OPEN, True: GraphicState.CLOSED}
 
     def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        if self.cooldown > 0.0:
+            self.cooldown -= elapsed_time
+
         if self.send_initial_signal:
             self.send_signal(self.signal)
             self.send_initial_signal = False
@@ -71,25 +76,36 @@ class Switch(Dynamic):
     def on_interaction(self, target: Dynamic, nature: Nature):
         # if target.is_player().value > 0:
         #     print(f"{target.is_player()} talked to me({self.name})")
+        if self.cooldown > 0.0:
+            return False
+
         if (
             nature == Nature.TALK
             and target.type == ObjectType.PLAYER
             and self.visible
         ):
             self.state_changed = True
-            self.engine.audio.play_sound("switch")
+            self.engine.audio.play_sound("switch", 0.2)
+            self.cooldown = self.cooldown_reset
+            print("Player talked")
 
         elif nature == Nature.WALK and target.type == ObjectType.PROJECTILE:
             if self.signal:
                 # Projectiles from the right will activate the switch
                 if target.px > self.px and target.vx < 0:
                     self.state_changed = True
+                    if "body" not in target.name:
+                        self.engine.audio.play_sound("switch", 0.2)
+                        self.cooldown = self.cooldown_reset
             else:
                 # Projectiles from the left will (de)activate the switch
-                if target.px <= self.px and target.vx > 0:
+                if (
+                    target.px <= self.px and target.vx > 0
+                ):  # Sword does not activate because vx=0
                     self.state_changed = True
-            if "body" not in target.name:
-                self.engine.audio.play_sound("switch")
+                    if "body" not in target.name:
+                        self.engine.audio.play_sound("switch", 0.2)
+                        self.cooldown = self.cooldown_reset
 
         elif nature == Nature.SIGNAL:
             self.visible = False

mima/scripts/commands/oneway_move.py

@@ -8,11 +8,12 @@ from ...util.constants import ONEWAY_SPEED_BOOST
 
 if TYPE_CHECKING:
     from ...objects.dynamic import Dynamic
+    from ...types.player import Player
 
 
 class CommandOnewayMove(Command):
-    def __init__(self, obj: Dynamic, vx: float, vy: float):
-        super().__init__()
+    def __init__(self, obj: Dynamic, vx: float, vy: float, player: Player):
+        super().__init__([player])
 
         self.obj: Dynamic = obj
         self.vx: float = vx
@@ -27,7 +28,7 @@ class CommandOnewayMove(Command):
         self.obj.solid_vs_map = False
         self.obj.solid_vs_dyn = False
         self.obj.vx = self.obj.vy = 0.0
-        self.obj.vz = 10.0
+        self.obj.vz = 7.5
 
         self.start_px = self.obj.px
         self.start_py = self.obj.py

mima/util/constants.py

@@ -10,8 +10,8 @@ UI_HIGHT: int = 1  # TODO: remove
 # Map transition
 MOVE_MAP_DURATION: float = 1.0
 MAP_TRANSITION_DURATION_FACTOR: float = 0.75
-ONEWAY_ACTIVATION_DELAY: float = 0.175
-ONEWAY_SPEED_BOOST: float = 2.0
+ONEWAY_ACTIVATION_DELAY: float = 0.075
+ONEWAY_SPEED_BOOST: float = 2.5
 
 # Gamepad
 AXIS_DEADZONE: float = 0.25
@@ -38,7 +38,7 @@ DEFAULT_GRAPHIC_TIMER_DAMAGED: float = 0.075
 DEFAULT_GRAPHIC_TIMER_DEAD: float = 0.25
 DEFAULT_GRAPHIC_TIMER: float = 0.5
 ATTRIBUTE_TIMER: float = 0.25
-DEFAULT_KNOCK_SPEED: float = 5.0
+DEFAULT_KNOCK_SPEED: float = 6.0
 
 # Gameplay
 ABYSS_DAMAGE: int = 1