@gg-web-engine/core 0.0.3 → 0.0.4

package/dist/base/gg-world.js

@@ -10,9 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GgWorld = void 0;
-const i_tick_listener_1 = require("./entities/interfaces/i-tick-listener");
+const gg_entity_1 = require("./entities/gg-entity");
 const gg_static_1 = require("./gg-static");
-const keyboard_controller_1 = require("./controllers/keyboard.controller");
+const keyboard_input_1 = require("./inputs/keyboard.input");
 const rxjs_1 = require("rxjs");
 const gg_console_ui_1 = require("./ui/gg-console.ui");
 const gg_debugger_ui_1 = require("./ui/gg-debugger.ui");
@@ -22,18 +22,17 @@ class GgWorld {
         this.visualScene = visualScene;
         this.physicsWorld = physicsWorld;
         this.consoleEnabled = consoleEnabled;
-        // world clock, can be paused/resumed. Stops when disposing world
         this.worldClock = global_clock_1.GgGlobalClock.instance.createChildClock(false);
-        // TODO consider adding mouse controller
-        this.keyboardController = new keyboard_controller_1.KeyboardController();
+        this.keyboardInput = new keyboard_input_1.KeyboardInput();
         this.children = [];
+        // the same as children, but sorted by tick order
         this.tickListeners = [];
         this.commands = {};
         gg_static_1.GgStatic.instance.worlds.push(this);
         gg_static_1.GgStatic.instance.selectedWorld = this;
-        this.keyboardController.start().then();
+        this.keyboardInput.start().then();
         if (consoleEnabled) {
-            this.keyboardController
+            this.keyboardInput
                 .bind('Backquote')
                 .pipe((0, rxjs_1.filter)(x => x))
                 .subscribe(() => {
@@ -76,23 +75,27 @@ class GgWorld {
             }), 'args: [0 or 1]; turn on/off physics debug view. Default value is 0');
         }
     }
-    get worldTime() {
-        return this.worldClock.elapsedTime;
-    }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             yield Promise.all([this.physicsWorld.init(), this.visualScene.init()]);
             this.worldClock.tick$.subscribe(([elapsed, delta]) => {
-                let physicsTickPerformed = false;
-                for (let i = 0; i < this.tickListeners.length; i++) {
-                    if (!physicsTickPerformed && this.tickListeners[i].tickOrder >= 500) {
-                        this.physicsWorld.simulate(delta);
-                        physicsTickPerformed = true;
+                let i = 0;
+                // emit tick to all entities with tick order < GGTickOrder.PHYSICS_SIMULATION
+                for (i; i < this.tickListeners.length; i++) {
+                    if (this.tickListeners[i].tickOrder >= gg_entity_1.GGTickOrder.PHYSICS_SIMULATION) {
+                        break;
+                    }
+                    if (this.tickListeners[i].active) {
+                        this.tickListeners[i].tick$.next([elapsed, delta]);
                     }
-                    this.tickListeners[i].tick$.next([elapsed, delta]);
                 }
-                if (!physicsTickPerformed) {
-                    this.physicsWorld.simulate(delta);
+                // run phycics simulation
+                this.physicsWorld.simulate(delta);
+                // emit tick to all remained entities
+                for (i; i < this.tickListeners.length; i++) {
+                    if (this.tickListeners[i].active) {
+                        this.tickListeners[i].tick$.next([elapsed, delta]);
+                    }
                 }
             });
         });
@@ -106,9 +109,22 @@ class GgWorld {
     resumeWorld() {
         this.worldClock.resume();
     }
+    get isRunning() {
+        return this.worldClock.isRunning;
+    }
+    get isPaused() {
+        return this.worldClock.isPaused;
+    }
+    get worldTime() {
+        return this.worldClock.elapsedTime;
+    }
+    createClock(autoStart) {
+        return this.worldClock.createChildClock(autoStart);
+    }
     dispose() {
         this.worldClock.stop();
         for (let i = 0; i < this.children.length; i++) {
+            this.children[i].onRemoved();
             this.children[i].dispose();
         }
         this.children.splice(0, this.children.length);
@@ -118,24 +134,26 @@ class GgWorld {
     }
     addEntity(entity) {
         if (!!entity.world) {
-            throw new Error('Entity already spawned');
+            console.warn('Trying to spawn entity, which is already spawned');
+            return;
         }
         this.children.push(entity);
-        if ((0, i_tick_listener_1.isITickListener)(entity)) {
-            this.tickListeners.push(entity);
-            this.tickListeners.sort((l1, l2) => l1.tickOrder - l2.tickOrder);
-        }
+        this.tickListeners.push(entity);
+        this.tickListeners.sort((l1, l2) => l1.tickOrder - l2.tickOrder);
         entity.onSpawned(this);
     }
     removeEntity(entity, dispose = true) {
-        if (entity.world !== this) {
-            throw new Error('Entity is not a part of this world');
-        }
-        this.children.splice(this.children.findIndex(x => x === entity), 1);
-        if ((0, i_tick_listener_1.isITickListener)(entity)) {
+        if (entity.world) {
+            if (entity.world !== this) {
+                throw new Error('Entity is not a part of this world');
+            }
+            this.children.splice(this.children.findIndex(x => x === entity), 1);
             this.tickListeners.splice(this.tickListeners.findIndex(x => x === entity), 1);
+            entity.onRemoved();
+        }
+        else {
+            console.warn('Trying to remove entity, which is not spawned');
         }
-        entity.onRemoved();
         if (dispose) {
             entity.dispose();
         }

package/dist/base/inputs/direction.keyboard-input.d.ts

@@ -0,0 +1,41 @@
+import { Observable } from 'rxjs';
+import { KeyboardInput } from './keyboard.input';
+import { Input } from './input';
+/**
+ * The type representing desired keymap for DirectionKeyboardInput
+ */
+export declare type DirectionKeyboardKeymap = 'arrows' | 'wasd' | 'wasd+arrows';
+/**
+ * The type of DirectionKeyboardInput output value
+ */
+export declare type DirectionKeyboardOutput = {
+    upDown?: boolean;
+    leftRight?: boolean;
+};
+/**
+ * An input class, responsible for handling direction keys and providing simple current direction observable.
+ * Supports two the most popular keyboard layouts: WASD and arrows.
+ */
+export declare class DirectionKeyboardInput extends Input {
+    protected readonly keyboard: KeyboardInput;
+    protected readonly keymap: DirectionKeyboardKeymap;
+    /**
+     * A subject that emits `DirectionKeyboardOutput` objects whenever the input changes.
+     */
+    private _output$;
+    /**
+     * Returns an observable that emits `DirectionKeyboardOutput` objects whenever the input changes.
+     */
+    get output$(): Observable<DirectionKeyboardOutput>;
+    /**
+     * Creates a new instance of the `DirectionKeyboardInput` class.
+     *
+     * @param keyboard The `KeyboardInput` instance to use for input handling. You should probably use one from the World instance
+     * @param keymap The `DirectionKeyboardKeymap` defining which keys to listen for.
+     */
+    constructor(keyboard: KeyboardInput, keymap: DirectionKeyboardKeymap);
+    /**
+     * Called when the input handling should start.
+     */
+    protected startInternal(): Promise<void>;
+}

package/dist/base/inputs/direction.keyboard-input.js

@@ -0,0 +1,85 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectionKeyboardInput = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const input_1 = require("./input");
+/**
+ * An input class, responsible for handling direction keys and providing simple current direction observable.
+ * Supports two the most popular keyboard layouts: WASD and arrows.
+ */
+class DirectionKeyboardInput extends input_1.Input {
+    /**
+     * Creates a new instance of the `DirectionKeyboardInput` class.
+     *
+     * @param keyboard The `KeyboardInput` instance to use for input handling. You should probably use one from the World instance
+     * @param keymap The `DirectionKeyboardKeymap` defining which keys to listen for.
+     */
+    constructor(keyboard, keymap) {
+        super();
+        this.keyboard = keyboard;
+        this.keymap = keymap;
+        /**
+         * A subject that emits `DirectionKeyboardOutput` objects whenever the input changes.
+         */
+        this._output$ = new rxjs_1.Subject();
+    }
+    /**
+     * Returns an observable that emits `DirectionKeyboardOutput` objects whenever the input changes.
+     */
+    get output$() {
+        return this._output$.asObservable();
+    }
+    /**
+     * Called when the input handling should start.
+     */
+    startInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize an array to hold the keys to listen for
+            const keys = [[], [], [], []];
+            // Add the "wasd" keys to the array if specified in the keymap
+            if (this.keymap.includes('wasd')) {
+                keys[0].push('KeyW');
+                keys[1].push('KeyA');
+                keys[2].push('KeyS');
+                keys[3].push('KeyD');
+            }
+            // Add the arrow keys to the array if specified in the keymap
+            if (this.keymap.includes('arrows')) {
+                keys[0].push('ArrowUp');
+                keys[1].push('ArrowLeft');
+                keys[2].push('ArrowDown');
+                keys[3].push('ArrowRight');
+            }
+            // Bind to the keyboard events for the specified keys
+            (0, rxjs_1.combineLatest)(keys.map(x => this.keyboard.bindMany(...x)))
+                .pipe(
+            // Stop listening when the `stop$` signal is received
+            (0, rxjs_1.takeUntil)(this.stop$), 
+            // Map the key states to a `DirectionKeyboardOutput` object
+            (0, operators_1.map)(moveDirection => {
+                const result = {};
+                if (moveDirection.includes(true)) {
+                    const [f, l, b, r] = moveDirection;
+                    if (f != b)
+                        result.upDown = f;
+                    if (l != r)
+                        result.leftRight = l;
+                }
+                return result;
+            }))
+                // Emit the resulting `DirectionKeyboardOutput` object through the `_output$` subject
+                .subscribe(this._output$);
+        });
+    }
+}
+exports.DirectionKeyboardInput = DirectionKeyboardInput;

package/dist/base/inputs/input.d.ts

@@ -0,0 +1,50 @@
+import { Subject } from 'rxjs';
+/**
+ * An abstract class that provides basic implementation for Input class.
+ * Input is an entity for handling input from user, such as mouse movements, key presses etc.
+ * Inputs are not bound to World-s and working independently by design.
+ *
+ * TStartParams - A type representing an array of input arguments for the start method. Items are recommended to be named.
+ *
+ * TStopParams - A type representing an array of input arguments for the stop method. Items are recommended to be named.
+ */
+export declare abstract class Input<TStartParams extends any[] = [], TStopParams extends any[] = []> {
+    /**
+     * A private boolean that represents the running state of the process.
+     */
+    private _running;
+    /**
+     * A protected subject that emits a void value when the process is stopped.
+     * Subclasses, when subscribing to something using rxjs, have to add pipe takeUntil(this.stop$),
+     * so everything will be unsubscribed when stopping input
+     */
+    protected readonly stop$: Subject<void>;
+    /**
+     * A public getter that returns the running state of the Input.
+     */
+    get running(): boolean;
+    /**
+     * An asynchronous method that starts the input. Do not override it
+     * @param args - An array of input arguments for the start method.
+     * @returns A Promise that resolves when the input is started.
+     */
+    start(...args: TStartParams): Promise<void>;
+    /**
+     * An asynchronous method that stops the input. Do not override it
+     * @param args - An array of input arguments for the stop method.
+     * @returns A Promise that resolves when the input is stopped.
+     */
+    stop(...args: TStopParams): Promise<void>;
+    /**
+     * An abstract asynchronous method that starts the input.
+     * @param args - An array of input arguments for the start method.
+     * @returns A Promise that resolves when the process is started.
+     */
+    protected abstract startInternal(...args: TStartParams): Promise<void>;
+    /**
+     * An asynchronous method that stops the input.
+     * @param args - An array of input arguments for the stop method.
+     * @returns A Promise that resolves when the process is stopped.
+     */
+    protected stopInternal(...args: TStopParams): Promise<void>;
+}

package/dist/base/inputs/input.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Input = void 0;
+const rxjs_1 = require("rxjs");
+/**
+ * An abstract class that provides basic implementation for Input class.
+ * Input is an entity for handling input from user, such as mouse movements, key presses etc.
+ * Inputs are not bound to World-s and working independently by design.
+ *
+ * TStartParams - A type representing an array of input arguments for the start method. Items are recommended to be named.
+ *
+ * TStopParams - A type representing an array of input arguments for the stop method. Items are recommended to be named.
+ */
+class Input {
+    constructor() {
+        /**
+         * A private boolean that represents the running state of the process.
+         */
+        this._running = false;
+        /**
+         * A protected subject that emits a void value when the process is stopped.
+         * Subclasses, when subscribing to something using rxjs, have to add pipe takeUntil(this.stop$),
+         * so everything will be unsubscribed when stopping input
+         */
+        this.stop$ = new rxjs_1.Subject();
+    }
+    /**
+     * A public getter that returns the running state of the Input.
+     */
+    get running() {
+        return this._running;
+    }
+    /**
+     * An asynchronous method that starts the input. Do not override it
+     * @param args - An array of input arguments for the start method.
+     * @returns A Promise that resolves when the input is started.
+     */
+    start(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.running) {
+                return;
+            }
+            yield this.startInternal(...args);
+            this._running = true;
+        });
+    }
+    /**
+     * An asynchronous method that stops the input. Do not override it
+     * @param args - An array of input arguments for the stop method.
+     * @returns A Promise that resolves when the input is stopped.
+     */
+    stop(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.running) {
+                return;
+            }
+            this.stop$.next();
+            yield this.stopInternal(...args);
+            this._running = false;
+        });
+    }
+    /**
+     * An asynchronous method that stops the input.
+     * @param args - An array of input arguments for the stop method.
+     * @returns A Promise that resolves when the process is stopped.
+     */
+    stopInternal(...args) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+}
+exports.Input = Input;

package/dist/base/inputs/keyboard.input.d.ts

@@ -0,0 +1,45 @@
+import { Input } from './input';
+import { Observable } from 'rxjs';
+/**
+ * A main keyboard input: it does not have own key bindings, but provides an API to bind keys.
+ * It is responsible for listening key up/down events (when running!) and emit the events to subscribers.
+ * Every World entity has its own dedicated instance of Keyboard input, which is running only when the world is running
+ */
+export declare class KeyboardInput extends Input {
+    private bindings;
+    /**
+     * Creates a new instance of the `KeyboardInput` class.
+     */
+    constructor();
+    protected startInternal(): Promise<void>;
+    protected stopInternal(): Promise<void>;
+    /**
+     * Creates an observable that emits a boolean whenever a key with the given code is pressed or released
+     * @param code The key code to bind the observable to
+     * @returns An observable that emits true when the key is pressed and false when it's released
+     */
+    bind(code: string): Observable<boolean>;
+    /**
+     * Creates an observable that emits a boolean indicating whether any of the keys with the given codes are pressed or released.
+     * Should be used when you have more than one keys, responsible for the same action.
+     * @param codes The key codes to bind the observable to
+     * @returns An observable that emits true when any of the keys are pressed and false when they're all released
+     */
+    bindMany(...codes: string[]): Observable<boolean>;
+    /**
+     * Emulates a key down event for the given key code
+     * @param code The key code to emulate
+     */
+    emulateKeyDown(code: string): void;
+    /**
+     * Emulates a key up event for the given key code
+     * @param code The key code to emulate
+     */
+    emulateKeyUp(code: string): void;
+    /**
+     * Emulates a key press event (down and up) for the given key code
+     * @param code The key code to emulate
+     */
+    emulateKeyPress(code: string): void;
+    private handleKeys;
+}

package/dist/base/inputs/keyboard.input.js

@@ -0,0 +1,130 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardInput = void 0;
+const input_1 = require("./input");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+/**
+ * A main keyboard input: it does not have own key bindings, but provides an API to bind keys.
+ * It is responsible for listening key up/down events (when running!) and emit the events to subscribers.
+ * Every World entity has its own dedicated instance of Keyboard input, which is running only when the world is running
+ */
+class KeyboardInput extends input_1.Input {
+    /**
+     * Creates a new instance of the `KeyboardInput` class.
+     */
+    constructor() {
+        super();
+        this.bindings = {};
+        this.handleKeys = this.handleKeys.bind(this);
+    }
+    startInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            window.addEventListener('keydown', this.handleKeys);
+            window.addEventListener('keyup', this.handleKeys);
+        });
+    }
+    stopInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            window.removeEventListener('keydown', this.handleKeys);
+            window.removeEventListener('keyup', this.handleKeys);
+        });
+    }
+    /**
+     * Creates an observable that emits a boolean whenever a key with the given code is pressed or released
+     * @param code The key code to bind the observable to
+     * @returns An observable that emits true when the key is pressed and false when it's released
+     */
+    bind(code) {
+        if (!this.bindings[code]) {
+            this.bindings[code] = [];
+        }
+        const subj = new rxjs_1.BehaviorSubject(false);
+        this.bindings[code].push(subj);
+        return subj.pipe((0, rxjs_1.finalize)(() => {
+            this.bindings[code].splice(this.bindings[code].indexOf(subj), 1);
+            subj.complete();
+        }));
+    }
+    /**
+     * Creates an observable that emits a boolean indicating whether any of the keys with the given codes are pressed or released.
+     * Should be used when you have more than one keys, responsible for the same action.
+     * @param codes The key codes to bind the observable to
+     * @returns An observable that emits true when any of the keys are pressed and false when they're all released
+     */
+    bindMany(...codes) {
+        if (codes.length == 0) {
+            console.warn('[KeyboardController] bindMany called without any key code');
+            return rxjs_1.NEVER;
+        }
+        if (codes.length == 1) {
+            return this.bind(codes[0]);
+        }
+        const subjects = [];
+        for (const code of codes) {
+            if (!this.bindings[code]) {
+                this.bindings[code] = [];
+            }
+            const subj = new rxjs_1.BehaviorSubject(false);
+            this.bindings[code].push(subj);
+            subjects.push(subj);
+        }
+        return (0, rxjs_1.combineLatest)(subjects).pipe((0, rxjs_1.finalize)(() => {
+            for (let i = 0; i < codes.length; i++) {
+                this.bindings[codes[i]].splice(this.bindings[codes[i]].indexOf(subjects[i]), 1);
+                subjects[i].complete();
+            }
+        }), (0, operators_1.map)(values => values.includes(true)));
+    }
+    /**
+     * Emulates a key down event for the given key code
+     * @param code The key code to emulate
+     */
+    emulateKeyDown(code) {
+        if (!this.running) {
+            return;
+        }
+        for (const subj of this.bindings[code] || []) {
+            subj.next(true);
+        }
+    }
+    /**
+     * Emulates a key up event for the given key code
+     * @param code The key code to emulate
+     */
+    emulateKeyUp(code) {
+        if (!this.running) {
+            return;
+        }
+        for (const subj of this.bindings[code] || []) {
+            subj.next(false);
+        }
+    }
+    /**
+     * Emulates a key press event (down and up) for the given key code
+     * @param code The key code to emulate
+     */
+    emulateKeyPress(code) {
+        this.emulateKeyDown(code);
+        this.emulateKeyUp(code);
+    }
+    handleKeys(e) {
+        if (e.type != 'keydown' && e.type != 'keyup') {
+            return;
+        }
+        const pressed = e.type == 'keydown';
+        for (const subj of this.bindings[e.code] || []) {
+            subj.next(pressed);
+        }
+    }
+}
+exports.KeyboardInput = KeyboardInput;

package/dist/base/inputs/mouse.input.d.ts

@@ -0,0 +1,57 @@
+import { Input } from './input';
+import { Observable } from 'rxjs';
+import { Point2 } from '../models/points';
+/**
+ * Options for pointer lock in a MouseInput.
+ *
+ * ignoreMovementWhenNotLocked: Whether to ignore mouse movement when pointer lock is not active.
+ *
+ * canvas: The canvas element to request pointer lock on.
+ */
+export declare type MouseInputPointLockOptions = {
+    ignoreMovementWhenNotLocked: boolean;
+    canvas: HTMLCanvasElement;
+};
+/**
+ * Options for a MouseInput.
+ *
+ * pointerLock: The options for pointer lock. Do not provide it to disable pointer lock functionality
+ */
+export declare type MouseInputOptions = {
+    pointerLock?: MouseInputPointLockOptions;
+};
+/**
+ * A class representing mouse input.
+ */
+export declare class MouseInput extends Input<[], [unlockPointer?: boolean]> {
+    private readonly options;
+    /**
+     * An observable of the change in the x position of the mouse.
+     */
+    get deltaX$(): Observable<number>;
+    /**
+     * An observable of the change in the y position of the mouse.
+     */
+    get deltaY$(): Observable<number>;
+    /**
+     An observable of the change in the position of the mouse.
+     */
+    get delta$(): Observable<Point2>;
+    private _delta$;
+    private stopped$;
+    /**
+     Creates an instance of MouseInput.
+     @param {MouseInputOptions} options - The options for the MouseInput.
+     */
+    constructor(options?: MouseInputOptions);
+    protected startInternal(): Promise<void>;
+    /**
+     Stop listening for mouse movement events.
+     @param {boolean} [unlockPointer=true] - Whether to exit pointer lock.
+     */
+    protected stopInternal(unlockPointer?: boolean): Promise<void>;
+    /**
+     Request pointer lock on the canvas element.
+     */
+    private canvasClickListener;
+}