@directivegames/genesys.js 3.1.24

package/dist/src/actors/PlayerController.js

@@ -0,0 +1,763 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var PlayerController_1;
+/**
+ * PlayerController - actor that translates user input into pawn movement.
+ *
+ * Detailed explanation:
+ * - Reads keyboard, mouse, and gamepad events, applying sensitivity and pointer lock options.
+ * - Forwards movement axes and button presses to the currently possessed `Pawn` instance.
+ * - Exposes delegate hooks so games can intercept raw input or extend processing logic.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Spawn one per player and call `possess` with a pawn instance to begin controlling it.
+ * - Bind to delegates like `onKeyDown` when you need custom handling beyond the default movement.
+ * - Disable pointer lock with the `noPointerLock` option for menu-driven or top-down games.
+ */
+import * as THREE from 'three';
+import { EngineClass } from '../systems/ClassRegistry.js';
+import { ConsoleCommand } from '../systems/ConsoleManager.js';
+import { GamepadAxis, GamepadButton } from '../systems/InputManager.js';
+import { MouseButton } from '../systems/InputManager.js';
+import { VirtualJoystickIndex } from '../systems/InputManager.js';
+import { Delegate } from '../utils/Delegate.js';
+import { ensure } from '../utils/Utils.js';
+import { Actor } from './Actor.js';
+let PlayerController = PlayerController_1 = class PlayerController extends Actor {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "pawn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "forward", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "backward", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "left", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "right", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "zoom", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "forwardKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['w', 'ArrowUp'].map(key => key.toLowerCase())
+        });
+        Object.defineProperty(this, "backwardKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['s', 'ArrowDown'].map(key => key.toLowerCase())
+        });
+        Object.defineProperty(this, "leftKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['a', 'ArrowLeft'].map(key => key.toLowerCase())
+        });
+        Object.defineProperty(this, "rightKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['d', 'ArrowRight'].map(key => key.toLowerCase())
+        });
+        Object.defineProperty(this, "zoomInKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['q'].map(key => key.toLowerCase())
+        });
+        Object.defineProperty(this, "zoomOutKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['e'].map(key => key.toLowerCase())
+        });
+        Object.defineProperty(this, "jumpKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [' '].map(key => key.toLowerCase())
+        });
+        Object.defineProperty(this, "reloadKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['r'].map(key => key.toLowerCase())
+        });
+        Object.defineProperty(this, "inputManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Add properties to track different input sources
+        Object.defineProperty(this, "mouseLookUp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "mouseLookRight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "gamepadLookUp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "gamepadLookRight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "joystickLookUp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "joystickLookRight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "lastInputDevice", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'keyboard'
+        });
+        Object.defineProperty(this, "joystickStartData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "onKeyDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onKeyUp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onMouseDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onMouseUp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        // Add gamepad delegate events
+        Object.defineProperty(this, "onGamepadButtonDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onGamepadButtonUp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onGamepadAxisChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+    }
+    /**
+       * Sets the input manager for this controller
+       * @param manager The input manager to use, or null to remove
+       */
+    setInputManager(manager) {
+        this.inputManager = manager;
+    }
+    /**
+       * Gets the current input manager
+       * @returns The current input manager or null if none is set
+       */
+    getInputManager() {
+        return this.inputManager;
+    }
+    /**
+       * Gets the currently possessed pawn
+       * @returns The possessed pawn or null if no pawn is possessed
+       */
+    getPawn() {
+        return this.pawn;
+    }
+    /**
+       * Handles key down events from the input system
+       * @param e The keyboard event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleKeyDown(e) {
+        // Track the active input device
+        this.setActiveInputDevice('keyboard');
+        if (this.pawn?.handleKeyDown(e)) {
+            return true;
+        }
+        if (this.onKeyDown.invokeWithPredicate(result => result, e).at(-1) ?? false) {
+            return true;
+        }
+        const key = e.key.toLocaleLowerCase();
+        if (this.forwardKeys.includes(key)) {
+            this.forward = 1;
+            return true;
+        }
+        else if (this.backwardKeys.includes(key)) {
+            this.backward = 1;
+            return true;
+        }
+        else if (this.leftKeys.includes(key)) {
+            this.left = 1;
+            return true;
+        }
+        else if (this.rightKeys.includes(key)) {
+            this.right = 1;
+            return true;
+        }
+        else if (this.zoomInKeys.includes(key)) {
+            this.zoom = 1;
+            return true;
+        }
+        else if (this.zoomOutKeys.includes(key)) {
+            this.zoom = -1;
+            return true;
+        }
+        else if (this.jumpKeys.includes(key)) {
+            if (this.pawn) {
+                this.pawn.jump();
+                return true;
+            }
+        }
+        else if (this.reloadKeys.includes(key)) {
+            if (this.pawn) {
+                this.pawn.reload();
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+       * Handles key up events from the input system
+       * @param e The keyboard event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleKeyUp(e) {
+        if (this.pawn?.handleKeyUp(e)) {
+            return true;
+        }
+        if (this.onKeyUp.invokeWithPredicate(result => result, e).at(-1) ?? false) {
+            return true;
+        }
+        const key = e.key.toLocaleLowerCase();
+        if (this.forwardKeys.includes(key)) {
+            this.forward = 0;
+            return true;
+        }
+        else if (this.backwardKeys.includes(key)) {
+            this.backward = 0;
+            return true;
+        }
+        else if (this.leftKeys.includes(key)) {
+            this.left = 0;
+            return true;
+        }
+        else if (this.rightKeys.includes(key)) {
+            this.right = 0;
+            return true;
+        }
+        else if (this.zoomInKeys.includes(key)) {
+            this.zoom = 0;
+            return true;
+        }
+        else if (this.zoomOutKeys.includes(key)) {
+            this.zoom = 0;
+            return true;
+        }
+        else if (this.jumpKeys.includes(key)) {
+            if (this.pawn) {
+                this.pawn.stopJump();
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+       * Handles mouse down events from the input system
+       * @param button The mouse event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleMouseDown(button, e) {
+        if (this.pawn?.handleMouseDown(button, e)) {
+            return true;
+        }
+        if (this.onMouseDown.invokeWithPredicate(result => result, button, e).at(-1) ?? false) {
+            return true;
+        }
+        if (button === MouseButton.Left) {
+            if (this.pawn?.beginFire() ?? false) {
+                return true;
+            }
+        }
+        else if (button === MouseButton.Right) {
+            if (this.pawn?.beginAltFire() ?? false) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+       * Handles mouse up events from the input system
+       * @param button The mouse event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleMouseUp(button, e) {
+        if (this.pawn?.handleMouseUp(button, e)) {
+            return true;
+        }
+        if (this.onMouseUp.invokeWithPredicate(result => result, button, e).at(-1) ?? false) {
+            return true;
+        }
+        if (button === MouseButton.Left) {
+            if (this.pawn?.endFire() ?? false) {
+                return true;
+            }
+        }
+        else if (button === MouseButton.Right) {
+            if (this.pawn?.endAltFire() ?? false) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+       * Handles mouse movement events from the input system
+       * @param e The mouse event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleMouseMove(e) {
+        if (!this.inputManager?.isPointerLocked()) {
+            return false;
+        }
+        // Track the active input device
+        this.setActiveInputDevice('mouse');
+        this.mouseLookUp += -e.movementY * PlayerController_1.inputSettings.lookSensitivity;
+        this.mouseLookRight += e.movementX * PlayerController_1.inputSettings.lookSensitivity;
+        return true;
+    }
+    /**
+       * Handles mouse click events from the input system
+       * @param button The mouse button that was clicked
+       * @param e The mouse event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleMouseClick(button, e) {
+        return false;
+    }
+    /**
+     * Handles virtual joystick events from the input system
+     * @param index The index of the virtual joystick
+     * @param joystickData The data from the virtual joystick
+     * @returns True if the event was handled, false otherwise
+     */
+    handleVirtualJoystick(index, joystickData) {
+        const inputSettings = PlayerController_1.inputSettings;
+        this.setActiveInputDevice('joystick');
+        if (joystickData.type === 'start') {
+            this.joystickStartData.set(index, joystickData);
+        }
+        else if (joystickData.type === 'end') {
+            this.joystickStartData.delete(index);
+            if (index === VirtualJoystickIndex.Left) {
+                this.forward = 0;
+                this.backward = 0;
+                this.left = 0;
+                this.right = 0;
+            }
+            else if (index === VirtualJoystickIndex.Right) {
+                this.joystickLookRight = 0;
+                this.joystickLookUp = 0;
+            }
+        }
+        else if (joystickData.type === 'move') {
+            const startData = this.joystickStartData.get(index);
+            if (startData) {
+                const deltaX = joystickData.position.x - startData.position.x;
+                const deltaY = joystickData.position.y - startData.position.y;
+                if (index === VirtualJoystickIndex.Left) {
+                    this.forward = THREE.MathUtils.clamp(-deltaY * inputSettings.joystickMovementSensitivity, 0, 1);
+                    this.backward = THREE.MathUtils.clamp(deltaY * inputSettings.joystickMovementSensitivity, 0, 1);
+                    this.left = THREE.MathUtils.clamp(-deltaX * inputSettings.joystickMovementSensitivity, 0, 1);
+                    this.right = THREE.MathUtils.clamp(deltaX * inputSettings.joystickMovementSensitivity, 0, 1);
+                }
+                else if (index === VirtualJoystickIndex.Right) {
+                    this.joystickLookRight = deltaX * inputSettings.joystickLookSensitivity;
+                    this.joystickLookUp = -deltaY * inputSettings.joystickLookSensitivity;
+                }
+            }
+            else {
+                this.joystickStartData.set(index, joystickData);
+            }
+        }
+        return true;
+    }
+    /**
+       * Track the active input device with a timestamp
+       * @param device The input device that was just used
+       */
+    setActiveInputDevice(device) {
+        this.lastInputDevice = device;
+    }
+    /**
+       * Handles gamepad button down events from the gamepad system
+       * @param gamepadIndex The index of the gamepad
+       * @param buttonIndex The index of the button
+       * @param value The value of the button press (0.0 to 1.0)
+       * @returns True if the event was handled, false otherwise
+       */
+    handleGamepadButtonDown(gamepadIndex, buttonIndex, value) {
+        // Only handle gamepad 0 by default (first connected gamepad)
+        if (gamepadIndex !== 0)
+            return false;
+        // Track the active input device
+        this.setActiveInputDevice('gamepad');
+        if (this.pawn?.handleGamepadButtonDown(gamepadIndex, buttonIndex, value)) {
+            return true;
+        }
+        if (this.onGamepadButtonDown.invokeWithPredicate(result => result, gamepadIndex, buttonIndex, value).at(-1) ?? false) {
+            return true;
+        }
+        if (buttonIndex === GamepadButton.FaceBottom) {
+            // Jump with bottom face button (A on Xbox, X on PlayStation)
+            if (this.pawn) {
+                this.pawn.jump();
+                return true;
+            }
+        }
+        else if (buttonIndex === GamepadButton.FaceLeft) {
+            // Reload with left face button (X on Xbox, Square on PlayStation)
+            if (this.pawn) {
+                this.pawn.reload();
+                return true;
+            }
+        }
+        else if (buttonIndex === GamepadButton.LeftTrigger) {
+            // Begin zoom in
+            this.zoom = value;
+            return true;
+        }
+        else if (buttonIndex === GamepadButton.RightTrigger) {
+            // Begin fire
+            if (this.pawn?.beginFire() ?? false) {
+                return true;
+            }
+        }
+        else if (buttonIndex === GamepadButton.LeftBumper) {
+            // Begin zoom out
+            this.zoom = -value;
+            return true;
+        }
+        else if (buttonIndex === GamepadButton.RightBumper) {
+            // Begin alt fire
+            if (this.pawn?.beginAltFire() ?? false) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+       * Handles gamepad button up events from the gamepad system
+       * @param gamepadIndex The index of the gamepad
+       * @param buttonIndex The index of the button
+       * @returns True if the event was handled, false otherwise
+       */
+    handleGamepadButtonUp(gamepadIndex, buttonIndex) {
+        // Only handle gamepad 0 by default (first connected gamepad)
+        if (gamepadIndex !== 0)
+            return false;
+        // Track the active input device
+        this.setActiveInputDevice('gamepad');
+        if (this.pawn?.handleGamepadButtonUp(gamepadIndex, buttonIndex)) {
+            return true;
+        }
+        if (this.onGamepadButtonUp.invokeWithPredicate(result => result, gamepadIndex, buttonIndex, 0).at(-1) ?? false) {
+            return true;
+        }
+        if (buttonIndex === GamepadButton.LeftTrigger || buttonIndex === GamepadButton.LeftBumper) {
+            // End zoom
+            this.zoom = 0;
+            return true;
+        }
+        else if (buttonIndex === GamepadButton.RightTrigger) {
+            // End fire
+            if (this.pawn?.endFire() ?? false) {
+                return true;
+            }
+        }
+        else if (buttonIndex === GamepadButton.RightBumper) {
+            // End alt fire
+            if (this.pawn?.endAltFire() ?? false) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+       * Handles gamepad axis change events from the gamepad system
+       * @param gamepadIndex The index of the gamepad
+       * @param axisIndex The index of the axis
+       * @param value The value of the axis (-1.0 to 1.0)
+       * @returns True if the event was handled, false otherwise
+       */
+    handleGamepadAxisChange(gamepadIndex, axisIndex, value) {
+        // Only handle standard gamepad 0
+        if (gamepadIndex !== 0)
+            return false;
+        // Only track active input device if there's significant input
+        // This prevents small axis noise from switching input device
+        if (Math.abs(value) > 0.25) {
+            this.setActiveInputDevice('gamepad');
+        }
+        if (this.pawn?.handleGamepadAxisChange(gamepadIndex, axisIndex, value)) {
+            return true;
+        }
+        if (this.onGamepadAxisChange.invokeWithPredicate(result => result, gamepadIndex, axisIndex, value).at(-1) ?? false) {
+            return true;
+        }
+        if (axisIndex === GamepadAxis.LeftStickX) {
+            // Left/Right movement
+            if (value > 0) {
+                this.right = value;
+                this.left = 0;
+            }
+            else {
+                this.right = 0;
+                this.left = -value;
+            }
+            return true;
+        }
+        else if (axisIndex === GamepadAxis.LeftStickY) {
+            // Forward/Backward movement
+            if (value > 0) {
+                this.backward = value;
+                this.forward = 0;
+            }
+            else {
+                this.backward = 0;
+                this.forward = -value;
+            }
+            return true;
+        }
+        else if (axisIndex === GamepadAxis.RightStickX) {
+            // Look right/left - store in separate gamepad variable
+            this.gamepadLookRight = value * PlayerController_1.inputSettings.gamepadLookSensitivity;
+            return true;
+        }
+        else if (axisIndex === GamepadAxis.RightStickY) {
+            // Look up/down - store in separate gamepad variable
+            this.gamepadLookUp = -value * PlayerController_1.inputSettings.gamepadLookSensitivity;
+            return true;
+        }
+        return false;
+    }
+    /**
+       * Called before physics simulation to process input and update the controlled pawn
+       * @param deltaTime Time elapsed since the last frame in seconds
+       */
+    tickPrePhysics(deltaTime) {
+        super.tickPrePhysics(deltaTime);
+        if (this.pawn) {
+            const forwardValue = this.forward - this.backward;
+            const rightValue = this.right - this.left;
+            // Use look values from the active input device
+            let lookUpValue = 0;
+            let lookRightValue = 0;
+            if (this.lastInputDevice === 'mouse') {
+                lookUpValue = this.mouseLookUp;
+                lookRightValue = this.mouseLookRight;
+            }
+            else if (this.lastInputDevice === 'gamepad') {
+                lookUpValue = this.gamepadLookUp;
+                lookRightValue = this.gamepadLookRight;
+            }
+            else if (this.lastInputDevice === 'joystick') {
+                lookUpValue = this.joystickLookUp;
+                lookRightValue = this.joystickLookRight;
+            }
+            // Movement inputs are typically speed-based (normalized range [-1, 1])
+            this.pawn.addForwardInput(forwardValue, false);
+            this.pawn.addRightInput(rightValue, false);
+            // Look inputs: mouse is absolute (accumulated pixels), gamepad/joystick are speed-based
+            this.pawn.addLookUpInput(lookUpValue, this.lastInputDevice === 'mouse');
+            this.pawn.addLookRightInput(lookRightValue, this.lastInputDevice === 'mouse');
+            // Zoom input is typically speed-based
+            this.pawn.addZoomInput(this.zoom, false);
+        }
+        // Always reset mouse look values each frame
+        this.mouseLookUp = 0;
+        this.mouseLookRight = 0;
+        // For gamepad, apply continuous input or decay
+        if (this.lastInputDevice === 'gamepad') {
+            // Stick is already at zero or at a maintained value from handleGamepadAxisChange
+            // No need for additional decay logic here
+        }
+        else {
+            // If gamepad is not active, decay its values to avoid lingering input
+            const GAMEPAD_DECAY = 0.2;
+            if (Math.abs(this.gamepadLookUp) < GAMEPAD_DECAY) {
+                this.gamepadLookUp = 0;
+            }
+            else if (this.gamepadLookUp > 0) {
+                this.gamepadLookUp -= GAMEPAD_DECAY;
+            }
+            else {
+                this.gamepadLookUp += GAMEPAD_DECAY;
+            }
+            if (Math.abs(this.gamepadLookRight) < GAMEPAD_DECAY) {
+                this.gamepadLookRight = 0;
+            }
+            else if (this.gamepadLookRight > 0) {
+                this.gamepadLookRight -= GAMEPAD_DECAY;
+            }
+            else {
+                this.gamepadLookRight += GAMEPAD_DECAY;
+            }
+        }
+    }
+    /**
+       * Releases control of the currently possessed pawn
+       */
+    unpossess() {
+        if (this.pawn) {
+            this.pawn.setPlayerController(null);
+        }
+        this.pawn = null;
+    }
+    /**
+       * Takes control of the specified pawn
+       * @param pawn The pawn to possess (control)
+       */
+    possess(pawn) {
+        this.pawn = pawn;
+        this.pawn.setPlayerController(this);
+    }
+    /**
+       * Restarts the player at the player start or a specified location
+       */
+    restartPlayer() {
+        const playerStart = this.getWorld()?.gameMode.findPlayerStart(this);
+        if (playerStart) {
+            ensure(this.pawn);
+            const playerStartTransform = playerStart.getWorldTransform();
+            this.pawn?.setWorldTransform({
+                position: playerStartTransform.position,
+                rotation: playerStartTransform.rotation,
+            });
+        }
+    }
+    getCamera() {
+        return this.pawn?.getCamera() ?? super.getCamera();
+    }
+    //====================================================================================================
+    doBeginPlay() {
+        super.doBeginPlay();
+        const world = this.getWorld();
+        world.consoleManager.addCommandHandler(this);
+        if (!this.options.noPointerLock) {
+            world.inputManager.requestPointerLock({});
+        }
+        world.inputManager.addInputHandler(this);
+        this.restartPlayer();
+    }
+    doEndPlay() {
+        super.doEndPlay();
+        this.getWorld()?.consoleManager.removeCommandHandler(this);
+        this.inputManager?.removeInputHandler(this);
+    }
+    restartPlayerCommand() {
+        this.restartPlayer();
+        return 'Restarted player';
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_Character';
+    }
+};
+// Movement settings
+Object.defineProperty(PlayerController, "inputSettings", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        lookSensitivity: 0.02,
+        gamepadLookSensitivity: 80.0,
+        joystickLookSensitivity: 0.6,
+        joystickMovementSensitivity: 0.03,
+    }
+});
+__decorate([
+    ConsoleCommand('restartplayer', 'Restart the current player'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", String)
+], PlayerController.prototype, "restartPlayerCommand", null);
+PlayerController = PlayerController_1 = __decorate([
+    EngineClass('PlayerController')
+], PlayerController);
+export { PlayerController };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PlayerController.js","sourceRoot":"","sources":["../../../src/actors/PlayerController.ts"],"names":[],"mappings":";;;;;;;;;;AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AA2B5B,IAAM,gBAAgB,wBAAtB,MAAM,gBAAiB,SAAQ,KAA8B;IAA7D;;QACG;;;;mBAAoB,IAAI;WAAC;QACzB;;;;mBAAkB,CAAC;WAAC;QACpB;;;;mBAAmB,CAAC;WAAC;QACrB;;;;mBAAe,CAAC;WAAC;QACjB;;;;mBAAgB,CAAC;WAAC;QAClB;;;;mBAAe,CAAC;WAAC;QAEjB;;;;mBAAwB,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;WAAC;QACvE;;;;mBAAyB,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;WAAC;QAC1E;;;;mBAAqB,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;WAAC;QACtE;;;;mBAAsB,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;WAAC;QACxE;;;;mBAAuB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;WAAC;QAC3D;;;;mBAAwB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;WAAC;QAC5D;;;;mBAAqB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;WAAC;QACzD;;;;mBAAuB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;WAAC;QAE3D;;;;mBAAoC,IAAI;WAAC;QAUjD,kDAAkD;QAC1C;;;;mBAAsB,CAAC;WAAC;QACxB;;;;mBAAyB,CAAC;WAAC;QAC3B;;;;mBAAwB,CAAC;WAAC;QAC1B;;;;mBAA2B,CAAC;WAAC;QAC7B;;;;mBAAyB,CAAC;WAAC;QAC3B;;;;mBAA4B,CAAC;WAAC;QAC9B;;;;mBAAgC,UAAU;WAAC;QAE3C;;;;mBAAoE,IAAI,GAAG,EAAE;WAAC;QAEtE;;;;mBAAmC,IAAI,QAAQ,EAA4B;WAAC;QAC5E;;;;mBAAiC,IAAI,QAAQ,EAA4B;WAAC;QAC1E;;;;mBAAkC,IAAI,QAAQ,EAAsC;WAAC;QACrF;;;;mBAAgC,IAAI,QAAQ,EAAsC;WAAC;QAEnG,8BAA8B;QACd;;;;mBAAkD,IAAI,QAAQ,EAA4C;WAAC;QAC3G;;;;mBAAgD,IAAI,QAAQ,EAA4C;WAAC;QACzG;;;;mBAAgD,IAAI,QAAQ,EAA0C;WAAC;IAqiBzH,CAAC;IAliBC;;;SAGK;IACE,eAAe,CAAC,OAA4B;QACjD,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC;IAC9B,CAAC;IAED;;;SAGK;IACE,eAAe;QACpB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED;;;SAGK;IACE,OAAO;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED;;;;SAIK;IACE,aAAa,CAAC,CAAgB;QACnC,gCAAgC;QAChC,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC;QAEtC,IAAI,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC;YAC5E,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,iBAAiB,EAAE,CAAC;QAEtC,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACnC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;YACjB,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC3C,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;YAClB,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACvC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;YACd,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACxC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;YACf,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;YACd,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1C,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;YACf,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACvC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBACd,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;gBACjB,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;aAAM,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACzC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBACd,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;gBACnB,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;SAIK;IACE,WAAW,CAAC,CAAgB;QACjC,IAAI,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC;YAC1E,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,iBAAiB,EAAE,CAAC;QAEtC,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACnC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;YACjB,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC3C,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;YAClB,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACvC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;YACd,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACxC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;YACf,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;YACd,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1C,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;YACd,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACvC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBACd,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACrB,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;SAIK;IACE,eAAe,CAAC,MAAmB,EAAE,CAAa;QACvD,IAAI,IAAI,CAAC,IAAI,EAAE,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC;YAC1C,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC;YACtF,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,MAAM,KAAK,WAAW,CAAC,IAAI,EAAE,CAAC;YAChC,IAAI,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,KAAK,EAAE,CAAC;gBACpC,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;aAAM,IAAI,MAAM,KAAK,WAAW,CAAC,KAAK,EAAE,CAAC;YACxC,IAAI,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,KAAK,EAAE,CAAC;gBACvC,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;SAIK;IACE,aAAa,CAAC,MAAmB,EAAE,CAAa;QACrD,IAAI,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC;YACxC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC;YACpF,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,MAAM,KAAK,WAAW,CAAC,IAAI,EAAE,CAAC;YAChC,IAAI,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,KAAK,EAAE,CAAC;gBAClC,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;aAAM,IAAI,MAAM,KAAK,WAAW,CAAC,KAAK,EAAE,CAAC;YACxC,IAAI,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,KAAK,EAAE,CAAC;gBACrC,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;SAIK;IACE,eAAe,CAAC,CAAa;QAClC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,eAAe,EAAE,EAAE,CAAC;YAC1C,OAAO,KAAK,CAAC;QACf,CAAC;QAED,gCAAgC;QAChC,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAEnC,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC,SAAS,GAAG,kBAAgB,CAAC,aAAa,CAAC,eAAe,CAAC;QAClF,IAAI,CAAC,cAAc,IAAI,CAAC,CAAC,SAAS,GAAG,kBAAgB,CAAC,aAAa,CAAC,eAAe,CAAC;QACpF,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;SAKK;IACE,gBAAgB,CAAC,MAAmB,EAAE,CAAa;QACxD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;OAKG;IACI,qBAAqB,CAAC,KAA2B,EAAE,YAAiC;QACzF,MAAM,aAAa,GAAG,kBAAgB,CAAC,aAAa,CAAC;QACrD,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC;QACtC,IAAI,YAAY,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAClC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;QAClD,CAAC;aAAM,IAAI,YAAY,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;YACvC,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACrC,IAAI,KAAK,KAAK,oBAAoB,CAAC,IAAI,EAAE,CAAC;gBACxC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;gBACjB,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;gBAClB,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;gBACd,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;YACjB,CAAC;iBAAM,IAAI,KAAK,KAAK,oBAAoB,CAAC,KAAK,EAAE,CAAC;gBAChD,IAAI,CAAC,iBAAiB,GAAG,CAAC,CAAC;gBAC3B,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC;aAAM,IAAI,YAAY,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YACxC,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACpD,IAAI,SAAS,EAAE,CAAC;gBACd,MAAM,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAC9D,MAAM,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAC9D,IAAI,KAAK,KAAK,oBAAoB,CAAC,IAAI,EAAE,CAAC;oBACxC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,aAAa,CAAC,2BAA2B,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;oBAChG,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,GAAG,aAAa,CAAC,2BAA2B,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;oBAChG,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,aAAa,CAAC,2BAA2B,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;oBAC7F,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,GAAG,aAAa,CAAC,2BAA2B,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC/F,CAAC;qBAAM,IAAI,KAAK,KAAK,oBAAoB,CAAC,KAAK,EAAE,CAAC;oBAChD,IAAI,CAAC,iBAAiB,GAAG,MAAM,GAAG,aAAa,CAAC,uBAAuB,CAAC;oBACxE,IAAI,CAAC,cAAc,GAAG,CAAC,MAAM,GAAG,aAAa,CAAC,uBAAuB,CAAC;gBACxE,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;YAClD,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;SAGK;IACG,oBAAoB,CAAC,MAAoB;QAC/C,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC;IAChC,CAAC;IAED;;;;;;SAMK;IACE,uBAAuB,CAAC,YAAoB,EAAE,WAAmB,EAAE,KAAa;QACrF,6DAA6D;QAC7D,IAAI,YAAY,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAErC,gCAAgC;QAChC,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC;QAErC,IAAI,IAAI,CAAC,IAAI,EAAE,uBAAuB,CAAC,YAAY,EAAE,WAA4B,EAAE,KAAK,CAAC,EAAE,CAAC;YAC1F,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,IAAI,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,WAA4B,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC;YACtI,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,WAAW,KAAK,aAAa,CAAC,UAAU,EAAE,CAAC;YAC7C,6DAA6D;YAC7D,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBACd,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;gBACjB,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;aAAM,IAAI,WAAW,KAAK,aAAa,CAAC,QAAQ,EAAE,CAAC;YAClD,kEAAkE;YAClE,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBACd,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;gBACnB,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;aAAM,IAAI,WAAW,KAAK,aAAa,CAAC,WAAW,EAAE,CAAC;YACrD,gBAAgB;YAChB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;YAClB,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,WAAW,KAAK,aAAa,CAAC,YAAY,EAAE,CAAC;YACtD,aAAa;YACb,IAAI,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,KAAK,EAAE,CAAC;gBACpC,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;aAAM,IAAI,WAAW,KAAK,aAAa,CAAC,UAAU,EAAE,CAAC;YACpD,iBAAiB;YACjB,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC;YACnB,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,WAAW,KAAK,aAAa,CAAC,WAAW,EAAE,CAAC;YACrD,iBAAiB;YACjB,IAAI,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,KAAK,EAAE,CAAC;gBACvC,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;SAKK;IACE,qBAAqB,CAAC,YAAoB,EAAE,WAAmB;QACpE,6DAA6D;QAC7D,IAAI,YAAY,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAErC,gCAAgC;QAChC,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC;QAErC,IAAI,IAAI,CAAC,IAAI,EAAE,qBAAqB,CAAC,YAAY,EAAE,WAA4B,CAAC,EAAE,CAAC;YACjF,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,WAA4B,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC;YAChI,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,WAAW,KAAK,aAAa,CAAC,WAAW,IAAI,WAAW,KAAK,aAAa,CAAC,UAAU,EAAE,CAAC;YAC1F,WAAW;YACX,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;YACd,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,WAAW,KAAK,aAAa,CAAC,YAAY,EAAE,CAAC;YACtD,WAAW;YACX,IAAI,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,KAAK,EAAE,CAAC;gBAClC,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;aAAM,IAAI,WAAW,KAAK,aAAa,CAAC,WAAW,EAAE,CAAC;YACrD,eAAe;YACf,IAAI,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,KAAK,EAAE,CAAC;gBACrC,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;SAMK;IACE,uBAAuB,CAAC,YAAoB,EAAE,SAAiB,EAAE,KAAa;QACnF,iCAAiC;QACjC,IAAI,YAAY,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAErC,8DAA8D;QAC9D,6DAA6D;QAC7D,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,CAAC;YAC3B,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC;QACvC,CAAC;QAED,IAAI,IAAI,CAAC,IAAI,EAAE,uBAAuB,CAAC,YAAY,EAAE,SAAwB,EAAE,KAAK,CAAC,EAAE,CAAC;YACtF,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,IAAI,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,SAAwB,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC;YAClI,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,SAAS,KAAK,WAAW,CAAC,UAAU,EAAE,CAAC;YACzC,sBAAsB;YACtB,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;gBACd,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;gBACnB,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;YAChB,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;gBACf,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC;YACrB,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,SAAS,KAAK,WAAW,CAAC,UAAU,EAAE,CAAC;YAChD,4BAA4B;YAC5B,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;gBACd,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;gBACtB,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;YACnB,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;gBAClB,IAAI,CAAC,OAAO,GAAG,CAAC,KAAK,CAAC;YACxB,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,SAAS,KAAK,WAAW,CAAC,WAAW,EAAE,CAAC;YACjD,uDAAuD;YACvD,IAAI,CAAC,gBAAgB,GAAG,KAAK,GAAG,kBAAgB,CAAC,aAAa,CAAC,sBAAsB,CAAC;YACtF,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,SAAS,KAAK,WAAW,CAAC,WAAW,EAAE,CAAC;YACjD,oDAAoD;YACpD,IAAI,CAAC,aAAa,GAAG,CAAC,KAAK,GAAG,kBAAgB,CAAC,aAAa,CAAC,sBAAsB,CAAC;YACpF,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAGD;;;SAGK;IACW,cAAc,CAAC,SAAiB;QAC9C,KAAK,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QAChC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC;YAClD,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC;YAE1C,+CAA+C;YAC/C,IAAI,WAAW,GAAG,CAAC,CAAC;YACpB,IAAI,cAAc,GAAG,CAAC,CAAC;YAEvB,IAAI,IAAI,CAAC,eAAe,KAAK,OAAO,EAAE,CAAC;gBACrC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;gBAC/B,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;YACvC,CAAC;iBAAM,IAAI,IAAI,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;gBAC9C,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC;gBACjC,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC;YACzC,CAAC;iBAAM,IAAI,IAAI,CAAC,eAAe,KAAK,UAAU,EAAE,CAAC;gBAC/C,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC;gBAClC,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC;YAC1C,CAAC;YAED,uEAAuE;YACvE,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;YAC/C,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;YAE3C,wFAAwF;YACxF,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE,IAAI,CAAC,eAAe,KAAK,OAAO,CAAC,CAAC;YACxE,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,IAAI,CAAC,eAAe,KAAK,OAAO,CAAC,CAAC;YAE9E,sCAAsC;YACtC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC3C,CAAC;QAED,4CAA4C;QAC5C,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;QAExB,+CAA+C;QAC/C,IAAI,IAAI,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;YACvC,iFAAiF;YACjF,0CAA0C;QAC5C,CAAC;aAAM,CAAC;YACN,sEAAsE;YACtE,MAAM,aAAa,GAAG,GAAG,CAAC;YAC1B,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,aAAa,EAAE,CAAC;gBACjD,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;YACzB,CAAC;iBAAM,IAAI,IAAI,CAAC,aAAa,GAAG,CAAC,EAAE,CAAC;gBAClC,IAAI,CAAC,aAAa,IAAI,aAAa,CAAC;YACtC,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,aAAa,IAAI,aAAa,CAAC;YACtC,CAAC;YAED,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,aAAa,EAAE,CAAC;gBACpD,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC;YAC5B,CAAC;iBAAM,IAAI,IAAI,CAAC,gBAAgB,GAAG,CAAC,EAAE,CAAC;gBACrC,IAAI,CAAC,gBAAgB,IAAI,aAAa,CAAC;YACzC,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,gBAAgB,IAAI,aAAa,CAAC;YACzC,CAAC;QACH,CAAC;IACH,CAAC;IAED;;SAEK;IACE,SAAS;QACd,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QACtC,CAAC;QACD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED;;;SAGK;IACE,OAAO,CAAC,IAAU;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC;IAED;;SAEK;IACE,aAAa;QAClB,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,EAAE,EAAE,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACpE,IAAI,WAAW,EAAE,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAClB,MAAM,oBAAoB,GAAG,WAAW,CAAC,iBAAiB,EAAE,CAAC;YAC7D,IAAI,CAAC,IAAI,EAAE,iBAAiB,CAAC;gBAC3B,QAAQ,EAAE,oBAAoB,CAAC,QAAQ;gBACvC,QAAQ,EAAE,oBAAoB,CAAC,QAAQ;aACxC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEe,SAAS;QACvB,OAAO,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;IACrD,CAAC;IAED,sGAAsG;IAEnF,WAAW;QAC5B,KAAK,CAAC,WAAW,EAAE,CAAC;QACpB,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAG,CAAC;QAC/B,KAAK,CAAC,cAAc,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YAChC,KAAK,CAAC,YAAY,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC;QAC5C,CAAC;QACD,KAAK,CAAC,YAAY,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAEzC,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC;IAEkB,SAAS;QAC1B,KAAK,CAAC,SAAS,EAAE,CAAC;QAClB,IAAI,CAAC,QAAQ,EAAE,EAAE,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAC3D,IAAI,CAAC,YAAY,EAAE,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAGO,oBAAoB;QAC1B,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,OAAO,kBAAkB,CAAC;IAC5B,CAAC;IAED,sGAAsG;IACtG,mBAAmB;IACnB,sGAAsG;IAEtF,kBAAkB;QAChC,OAAO,gBAAgB,CAAC;IAC1B,CAAC;;AA/jBD,oBAAoB;AACN;;;;WAAgB;QAC5B,eAAe,EAAE,IAAI;QACrB,sBAAsB,EAAE,IAAI;QAC5B,uBAAuB,EAAE,GAAG;QAC5B,2BAA2B,EAAE,IAAI;KAClC;EAL0B,CAKzB;AA8iBM;IADP,cAAc,CAAC,eAAe,EAAE,4BAA4B,CAAC;;;;4DAI7D;AA1kBU,gBAAgB;IAD5B,WAAW,CAAC,kBAAkB,CAAC;GACnB,gBAAgB,CAmlB5B"}