created interface to implement for UserInputManager

front/src/Interfaces/UserInputHandlerInterface.ts

@@ -0,0 +1,10 @@
+export interface UserInputHandlerInterface {
+    handleMouseWheelEvent: (
+        pointer: Phaser.Input.Pointer,
+        gameObjects: Phaser.GameObjects.GameObject[],
+        deltaX: number,
+        deltaY: number,
+        deltaZ: number
+    ) => void;
+    handleSpaceKeyUpEvent: (event: Event) => Event;
+}

front/src/Phaser/Game/GameScene.ts

@@ -90,6 +90,7 @@ import FILE_LOAD_ERROR = Phaser.Loader.Events.FILE_LOAD_ERROR;
 import { MapStore } from "../../Stores/Utils/MapStore";
 import { followUsersColorStore } from "../../Stores/FollowStore";
 import Camera = Phaser.Cameras.Scene2D.Camera;
+import { GameSceneUserInputHandler } from "../UserInput/GameSceneUserInputHandler";
 
 export interface GameSceneInitInterface {
     initPosition: PointInterface | null;
@@ -548,7 +549,7 @@ export class GameScene extends DirtyScene {
         this.MapPlayers = this.physics.add.group({ immovable: true });
 
         //create input to move
-        this.userInputManager = new UserInputManager(this);
+        this.userInputManager = new UserInputManager(this, new GameSceneUserInputHandler(this));
         mediaManager.setUserInputManager(this.userInputManager);
 
         if (localUserStore.getFullscreen()) {
@@ -607,10 +608,6 @@ export class GameScene extends DirtyScene {
             scriptPromises.push(iframeListener.registerScript(script, !disableModuleMode));
         }
 
-        this.userInputManager.spaceEvent(() => {
-            this.outlinedItem?.activate();
-        });
-
         this.reposition();
 
         // From now, this game scene will be notified of reposition events
@@ -679,6 +676,10 @@ export class GameScene extends DirtyScene {
             );
     }
 
+    public activateOutlinedItem(): void {
+        this.outlinedItem?.activate();
+    }
+
     /**
      * Initializes the connection to Pusher.
      */

front/src/Phaser/UserInput/GameSceneUserInputHandler.ts

@@ -0,0 +1,25 @@
+import type { UserInputHandlerInterface } from "../../Interfaces/UserInputHandlerInterface";
+import type { GameScene } from "../Game/GameScene";
+
+export class GameSceneUserInputHandler implements UserInputHandlerInterface {
+    private gameScene: GameScene;
+
+    constructor(gameScene: GameScene) {
+        this.gameScene = gameScene;
+    }
+
+    public handleMouseWheelEvent(
+        pointer: Phaser.Input.Pointer,
+        gameObjects: Phaser.GameObjects.GameObject[],
+        deltaX: number,
+        deltaY: number,
+        deltaZ: number
+    ): void {
+        this.gameScene.zoomByFactor(1 - (deltaY / 53) * 0.1);
+    }
+
+    public handleSpaceKeyUpEvent(event: Event): Event {
+        this.gameScene.activateOutlinedItem();
+        return event;
+    }
+}

front/src/Phaser/UserInput/UserInputManager.ts

@@ -1,8 +1,8 @@
-import type { GameScene } from "../Game/GameScene";
 import { touchScreenManager } from "../../Touch/TouchScreenManager";
 import { MobileJoystick } from "../Components/MobileJoystick";
 import { enableUserInputsStore } from "../../Stores/UserInputStore";
 import type { Direction } from "phaser3-rex-plugins/plugins/virtualjoystick.js";
+import type { UserInputHandlerInterface } from "../../Interfaces/UserInputHandlerInterface";
 
 interface UserInputManagerDatum {
     keyInstance: Phaser.Input.Keyboard.Key;
@@ -41,8 +41,8 @@ export class ActiveEventList {
 
 //this class is responsible for catching user inputs and listing all active user actions at every game tick events.
 export class UserInputManager {
-    private KeysCode!: UserInputManagerDatum[];
+    private keysCode!: UserInputManagerDatum[];
-    private Scene: GameScene;
+    private scene: Phaser.Scene;
     private isInputDisabled: boolean;
 
     private joystick!: MobileJoystick;
@@ -51,11 +51,15 @@ export class UserInputManager {
     private joystickForceAccuX = 0;
     private joystickForceAccuY = 0;
 
-    constructor(Scene: GameScene) {
+    private userInputHandler: UserInputHandlerInterface;
-        this.Scene = Scene;
+
+    constructor(scene: Phaser.Scene, userInputHandler: UserInputHandlerInterface) {
+        this.scene = scene;
+        this.userInputHandler = userInputHandler;
+
         this.isInputDisabled = false;
         this.initKeyBoardEvent();
-        this.initMouseWheel();
+        this.bindInputEventHandlers();
         if (touchScreenManager.supportTouchScreen) {
             this.initVirtualJoystick();
         }
@@ -66,7 +70,7 @@ export class UserInputManager {
     }
 
     initVirtualJoystick() {
-        this.joystick = new MobileJoystick(this.Scene);
+        this.joystick = new MobileJoystick(this.scene);
         this.joystick.on("update", () => {
             this.joystickForceAccuX = this.joystick.forceX ? this.joystickForceAccuX : 0;
             this.joystickForceAccuY = this.joystick.forceY ? this.joystickForceAccuY : 0;
@@ -92,80 +96,80 @@ export class UserInputManager {
     }
 
     initKeyBoardEvent() {
-        this.KeysCode = [
+        this.keysCode = [
             {
                 event: UserInputEvent.MoveUp,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.Z, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.Z, false),
             },
             {
                 event: UserInputEvent.MoveUp,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.W, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.W, false),
             },
             {
                 event: UserInputEvent.MoveLeft,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.Q, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.Q, false),
             },
             {
                 event: UserInputEvent.MoveLeft,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.A, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.A, false),
             },
             {
                 event: UserInputEvent.MoveDown,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.S, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.S, false),
             },
             {
                 event: UserInputEvent.MoveRight,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.D, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.D, false),
             },
 
             {
                 event: UserInputEvent.MoveUp,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.UP, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.UP, false),
             },
             {
                 event: UserInputEvent.MoveLeft,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.LEFT, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.LEFT, false),
             },
             {
                 event: UserInputEvent.MoveDown,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.DOWN, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.DOWN, false),
             },
             {
                 event: UserInputEvent.MoveRight,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.RIGHT, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.RIGHT, false),
             },
 
             {
                 event: UserInputEvent.SpeedUp,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SHIFT, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SHIFT, false),
             },
 
             {
                 event: UserInputEvent.Interact,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.E, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.E, false),
             },
             {
                 event: UserInputEvent.Interact,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SPACE, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SPACE, false),
             },
             {
                 event: UserInputEvent.Follow,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.F, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.F, false),
             },
             {
                 event: UserInputEvent.Shout,
-                keyInstance: this.Scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.F, false),
+                keyInstance: this.scene.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.F, false),
             },
         ];
     }
 
     clearAllListeners() {
-        this.Scene.input.keyboard.removeAllListeners();
+        this.scene.input.keyboard.removeAllListeners();
     }
 
     //todo: should we also disable the joystick?
     disableControls() {
-        this.Scene.input.keyboard.removeAllKeys();
+        this.scene.input.keyboard.removeAllKeys();
         this.isInputDisabled = true;
     }
 
@@ -201,7 +205,7 @@ export class UserInputManager {
             }
         });
         eventsMap.set(UserInputEvent.JoystickMove, this.joystickEvents.any());
-        this.KeysCode.forEach((d) => {
+        this.keysCode.forEach((d) => {
             if (d.keyInstance.isDown) {
                 eventsMap.set(d.event, true);
             }
@@ -209,30 +213,36 @@ export class UserInputManager {
         return eventsMap;
     }
 
-    spaceEvent(callback: Function) {
-        this.Scene.input.keyboard.on("keyup-SPACE", (event: Event) => {
-            callback();
-            return event;
-        });
-    }
-
     addSpaceEventListner(callback: Function) {
-        this.Scene.input.keyboard.addListener("keyup-SPACE", callback);
+        this.scene.input.keyboard.addListener("keyup-SPACE", callback);
     }
     removeSpaceEventListner(callback: Function) {
-        this.Scene.input.keyboard.removeListener("keyup-SPACE", callback);
+        this.scene.input.keyboard.removeListener("keyup-SPACE", callback);
     }
 
     destroy(): void {
         this.joystick?.destroy();
     }
 
-    private initMouseWheel() {
+    private bindInputEventHandlers() {
-        this.Scene.input.on(
+        this.scene.input.on(
             "wheel",
-            (pointer: unknown, gameObjects: unknown, deltaX: number, deltaY: number, deltaZ: number) => {
+            (
-                this.Scene.zoomByFactor(1 - (deltaY / 53) * 0.1);
+                pointer: Phaser.Input.Pointer,
+                gameObjects: Phaser.GameObjects.GameObject[],
+                deltaX: number,
+                deltaY: number,
+                deltaZ: number
+            ) => {
+                if (this.isInputDisabled) {
+                    return;
+                }
+                this.userInputHandler.handleMouseWheelEvent(pointer, gameObjects, deltaX, deltaY, deltaZ);
             }
         );
+
+        this.scene.input.keyboard.on("keyup-SPACE", (event: Event) => {
+            this.userInputHandler.handleSpaceKeyUpEvent(event);
+        });
     }
 }