@gg-web-engine/core 0.0.3 → 0.0.4

package/dist/2d/entities/controllers/entity-2d-positioning.animator.js

@@ -16,7 +16,7 @@ class Entity2dPositioningAnimator extends animation_mixer_1.AnimationMixer {
     }
     onSpawned(world) {
         super.onSpawned(world);
-        this.value$.pipe((0, rxjs_1.takeUntil)(this.removed$)).subscribe(value => this.applyPositioning(value));
+        this.value$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(value => this.applyPositioning(value));
     }
     applyPositioning(value) {
         this.entity.position = value.position;

package/dist/2d/entities/gg-2d-entity.d.ts

@@ -1,14 +1,12 @@
-import { Subject } from 'rxjs';
 import { GgPositionable2dEntity } from './gg-positionable-2d-entity';
-import { ITickListener } from '../../base/entities/interfaces/i-tick-listener';
 import { Point2 } from '../../base/models/points';
 import { IGg2dBody, IGg2dObject } from '../interfaces';
 import { Gg2dWorld } from '../gg-2d-world';
-export declare class Gg2dEntity extends GgPositionable2dEntity implements ITickListener {
+import { GGTickOrder } from '../../base/entities/gg-entity';
+export declare class Gg2dEntity extends GgPositionable2dEntity {
     readonly object2D: IGg2dObject | null;
     readonly objectBody: IGg2dBody | null;
-    readonly tick$: Subject<[number, number]>;
-    readonly tickOrder = 750;
+    readonly tickOrder = GGTickOrder.OBJECTS_BINDING;
     get position(): Point2;
     set position(value: Point2);
     get rotation(): number;

package/dist/2d/entities/gg-2d-entity.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Gg2dEntity = void 0;
-const rxjs_1 = require("rxjs");
 const gg_positionable_2d_entity_1 = require("./gg-positionable-2d-entity");
+const gg_entity_1 = require("../../base/entities/gg-entity");
 class Gg2dEntity extends gg_positionable_2d_entity_1.GgPositionable2dEntity {
     constructor(object2D, objectBody) {
         super();
         this.object2D = object2D;
         this.objectBody = objectBody;
-        this.tick$ = new rxjs_1.Subject();
-        this.tickOrder = 750;
+        this.tickOrder = gg_entity_1.GGTickOrder.OBJECTS_BINDING;
         if (objectBody) {
             objectBody.entity = this;
             this.tick$.subscribe(() => {

package/dist/3d/entities/controllers/animators/camera-3d.animator.d.ts

@@ -0,0 +1,17 @@
+import { AnimationFunction, AnimationMixer } from '../../../../base/entities/controllers/animation-mixer';
+import { Point3 } from '../../../../base/models/points';
+import { Gg3dWorld } from '../../../gg-3d-world';
+import { Gg3dCameraEntity } from '../../gg-3d-camera.entity';
+export declare type Camera3dAnimationArgs = {
+    position: Point3;
+    target: Point3;
+    up?: Point3;
+    fov?: number;
+};
+export declare class Camera3dAnimator extends AnimationMixer<Camera3dAnimationArgs> {
+    entity: Gg3dCameraEntity;
+    protected _animationFunction: AnimationFunction<Camera3dAnimationArgs>;
+    constructor(entity: Gg3dCameraEntity, _animationFunction: AnimationFunction<Camera3dAnimationArgs>);
+    onSpawned(world: Gg3dWorld): void;
+    protected applyPositioning(value: Camera3dAnimationArgs): void;
+}

package/dist/3d/entities/controllers/animators/camera-3d.animator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Camera3dAnimator = void 0;
+const animation_mixer_1 = require("../../../../base/entities/controllers/animation-mixer");
+const point3_1 = require("../../../../base/math/point3");
+const quaternion_1 = require("../../../../base/math/quaternion");
+const rxjs_1 = require("rxjs");
+const numbers_1 = require("../../../../base/math/numbers");
+const defaultUp = { x: 0, y: 0, z: 1 };
+const defaultFov = 65;
+class Camera3dAnimator extends animation_mixer_1.AnimationMixer {
+    constructor(entity, _animationFunction) {
+        super(_animationFunction, (a, b, t) => ({
+            position: point3_1.Pnt3.lerp(a.position, b.position, t),
+            target: point3_1.Pnt3.lerp(a.target, b.target, t),
+            up: point3_1.Pnt3.lerp(a.up || defaultUp, b.up || defaultUp, t),
+            fov: (0, numbers_1.lerpNumber)(a.fov || defaultFov, b.fov || defaultFov, t),
+        }));
+        this.entity = entity;
+        this._animationFunction = _animationFunction;
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.value$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(value => this.applyPositioning(value));
+    }
+    applyPositioning(value) {
+        this.entity.position = value.position;
+        this.entity.rotation = quaternion_1.Qtrn.lookAt(value.position, value.target, value.up || defaultUp);
+        this.entity.fov = value.fov || defaultFov;
+    }
+}
+exports.Camera3dAnimator = Camera3dAnimator;

package/dist/3d/entities/controllers/animators/entity-3d-positioning.animator.d.ts

@@ -0,0 +1,16 @@
+import { Gg3dEntity } from '../../gg-3d-entity';
+import { AnimationFunction, AnimationMixer } from '../../../../base/entities/controllers/animation-mixer';
+import { Point3, Point4 } from '../../../../base/models/points';
+import { Gg3dWorld } from '../../../gg-3d-world';
+declare type Positioning3d = {
+    position: Point3;
+    rotation: Point4;
+};
+export declare class Entity3dPositioningAnimator<T extends Gg3dEntity = Gg3dEntity> extends AnimationMixer<Positioning3d> {
+    entity: T;
+    protected _animationFunction: AnimationFunction<Positioning3d>;
+    constructor(entity: T, _animationFunction: AnimationFunction<Positioning3d>);
+    onSpawned(world: Gg3dWorld): void;
+    protected applyPositioning(value: Positioning3d): void;
+}
+export {};

package/dist/3d/entities/controllers/animators/entity-3d-positioning.animator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity3dPositioningAnimator = void 0;
+const animation_mixer_1 = require("../../../../base/entities/controllers/animation-mixer");
+const point3_1 = require("../../../../base/math/point3");
+const quaternion_1 = require("../../../../base/math/quaternion");
+const rxjs_1 = require("rxjs");
+class Entity3dPositioningAnimator extends animation_mixer_1.AnimationMixer {
+    constructor(entity, _animationFunction) {
+        super(_animationFunction, (a, b, t) => ({
+            position: point3_1.Pnt3.lerp(a.position, b.position, t),
+            rotation: quaternion_1.Qtrn.slerp(a.rotation, b.rotation, t),
+        }));
+        this.entity = entity;
+        this._animationFunction = _animationFunction;
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.value$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(value => this.applyPositioning(value));
+    }
+    applyPositioning(value) {
+        this.entity.position = value.position;
+        this.entity.rotation = value.rotation;
+    }
+}
+exports.Entity3dPositioningAnimator = Entity3dPositioningAnimator;

package/dist/3d/entities/controllers/input/car-keyboard-handling.controller.d.ts

@@ -0,0 +1,25 @@
+import { BehaviorSubject } from 'rxjs';
+import { KeyboardInput } from '../../../../base/inputs/keyboard.input';
+import { Gg3dRaycastVehicleEntity } from '../../gg-3d-raycast-vehicle.entity';
+import { DirectionKeyboardInput, DirectionKeyboardKeymap } from '../../../../base/inputs/direction.keyboard-input';
+import { GgEntity, GGTickOrder } from '../../../../base/entities/gg-entity';
+import { GgWorld } from '../../../../base/gg-world';
+export declare type CarKeyboardControllerOptions = {
+    keymap: DirectionKeyboardKeymap;
+    gearUpDownKeys: [string, string];
+};
+export declare class CarKeyboardHandlingController extends GgEntity {
+    protected readonly keyboard: KeyboardInput;
+    car: Gg3dRaycastVehicleEntity | null;
+    protected readonly options: CarKeyboardControllerOptions;
+    readonly tickOrder = GGTickOrder.INPUT_CONTROLLERS;
+    protected readonly directionsInput: DirectionKeyboardInput;
+    protected readonly x$: BehaviorSubject<number>;
+    protected readonly y$: BehaviorSubject<number>;
+    protected lastX: number;
+    switchingGearsEnabled: boolean;
+    pairTickerPipe: import("rxjs").UnaryFunction<import("rxjs").Observable<number>, import("rxjs").Observable<number>>;
+    constructor(keyboard: KeyboardInput, car: Gg3dRaycastVehicleEntity | null, options?: CarKeyboardControllerOptions);
+    onSpawned(world: GgWorld<any, any>): Promise<void>;
+    onRemoved(): Promise<void>;
+}

package/dist/3d/entities/controllers/input/car-keyboard-handling.controller.js

@@ -0,0 +1,105 @@
+"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.CarKeyboardHandlingController = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const direction_keyboard_input_1 = require("../../../../base/inputs/direction.keyboard-input");
+const gg_entity_1 = require("../../../../base/entities/gg-entity");
+// TODO pass as settings
+// TODO smooth y?
+const TICKER_INTERVAL = 16;
+const TICKER_MAX_STEPS = 10;
+class CarKeyboardHandlingController extends gg_entity_1.GgEntity {
+    constructor(keyboard, car, options = { keymap: 'arrows', gearUpDownKeys: ['KeyA', 'KeyZ'] }) {
+        super();
+        this.keyboard = keyboard;
+        this.car = car;
+        this.options = options;
+        this.tickOrder = gg_entity_1.GGTickOrder.INPUT_CONTROLLERS;
+        // emits values -1 - 1; -1 = full turn left; 1 = full turn right
+        this.x$ = new rxjs_1.BehaviorSubject(0);
+        // emits values -1 - 1; -1 = full brake; 1 = full acceleration
+        this.y$ = new rxjs_1.BehaviorSubject(0);
+        this.lastX = 0;
+        this.switchingGearsEnabled = true;
+        this.pairTickerPipe = (0, rxjs_1.pipe)((0, operators_1.startWith)(0), (0, operators_1.pairwise)(), (0, operators_1.map)(([beforeValue, afterValue]) => [this.lastX, afterValue]), (0, operators_1.switchMap)(([beforeValue, afterValue]) => (0, rxjs_1.interval)(TICKER_INTERVAL).pipe((0, operators_1.take)(TICKER_MAX_STEPS), (0, operators_1.map)(count => ++count), (0, operators_1.map)(count => beforeValue * ((TICKER_MAX_STEPS - count) / TICKER_MAX_STEPS) + afterValue * (count / TICKER_MAX_STEPS)), (0, operators_1.tap)(x => {
+            this.lastX = x;
+        }))));
+        this.directionsInput = new direction_keyboard_input_1.DirectionKeyboardInput(keyboard, options.keymap);
+    }
+    onSpawned(world) {
+        const _super = Object.create(null, {
+            onSpawned: { get: () => super.onSpawned }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.onSpawned.call(this, world);
+            let moveDirection = {};
+            this.keyboard
+                .bind(this.options.gearUpDownKeys[0])
+                .pipe((0, rxjs_1.takeUntil)(this._onRemoved$), (0, rxjs_1.filter)(x => this.switchingGearsEnabled && !!x))
+                .subscribe(() => {
+                if (this.car && (!this.car.carProperties.transmission.isAuto || this.car.gear <= 0)) {
+                    this.car.gear++;
+                }
+            });
+            this.keyboard
+                .bind(this.options.gearUpDownKeys[1])
+                .pipe((0, rxjs_1.takeUntil)(this._onRemoved$), (0, rxjs_1.filter)(x => this.switchingGearsEnabled && !!x))
+                .subscribe(() => {
+                if (this.car) {
+                    if (this.car.carProperties.transmission.isAuto && this.car.gear > 1) {
+                        this.car.gear = 0;
+                    }
+                    else {
+                        this.car.gear--;
+                    }
+                }
+            });
+            this.directionsInput.output$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(d => {
+                moveDirection = d;
+            });
+            this.tick$
+                .pipe((0, rxjs_1.takeUntil)(this._onRemoved$), (0, operators_1.map)(() => {
+                const direction = [0, 0];
+                if (moveDirection.leftRight !== undefined)
+                    direction[0] = moveDirection.leftRight ? -1 : 1;
+                if (moveDirection.upDown !== undefined)
+                    direction[1] = moveDirection.upDown ? 1 : -1;
+                return direction;
+            }))
+                .subscribe(([x, y]) => {
+                this.x$.next(x);
+                this.y$.next(y);
+            });
+            (0, rxjs_1.combineLatest)([
+                this.x$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$), (0, operators_1.distinctUntilChanged)(), this.pairTickerPipe),
+                this.y$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$), (0, operators_1.distinctUntilChanged)()),
+            ]).subscribe(([x, y]) => {
+                if (this.car) {
+                    this.car.setXAxisControlValue(x);
+                    this.car.setYAxisControlValue(y);
+                }
+            });
+            yield this.directionsInput.start();
+        });
+    }
+    onRemoved() {
+        const _super = Object.create(null, {
+            onRemoved: { get: () => super.onRemoved }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.onRemoved.call(this);
+            yield this.directionsInput.stop();
+        });
+    }
+}
+exports.CarKeyboardHandlingController = CarKeyboardHandlingController;

package/dist/3d/entities/controllers/input/free-camera.controller.d.ts

@@ -0,0 +1,54 @@
+import { MouseInput, MouseInputOptions } from '../../../../base/inputs/mouse.input';
+import { Gg3dCameraEntity } from '../../gg-3d-camera.entity';
+import { KeyboardInput } from '../../../../base/inputs/keyboard.input';
+import { DirectionKeyboardInput, DirectionKeyboardKeymap } from '../../../../base/inputs/direction.keyboard-input';
+import { GgEntity, GGTickOrder } from '../../../../base/entities/gg-entity';
+import { GgWorld } from '../../../../base/gg-world';
+/**
+ * Options for configuring a FreeCameraInput controller.
+ */
+export declare type FreeCameraControllerOptions = {
+    /**
+     * A keymap for controlling camera movement, where each key corresponds to a movement direction.
+     */
+    keymap: DirectionKeyboardKeymap;
+    /**
+     * Options for configuring camera movement.
+     */
+    movementOptions: {
+        /**
+         * The speed of camera movement.
+         */
+        speed: number;
+    };
+    /**
+     * Options for configuring mouse input.
+     */
+    mouseOptions: MouseInputOptions;
+};
+/**
+ * A controller for a free-moving camera.
+ */
+export declare class FreeCameraController extends GgEntity {
+    protected readonly keyboard: KeyboardInput;
+    protected readonly camera: Gg3dCameraEntity;
+    protected readonly options: FreeCameraControllerOptions;
+    readonly tickOrder = GGTickOrder.INPUT_CONTROLLERS;
+    /**
+     * The mouse input controller used for camera rotation.
+     */
+    protected readonly mouseInput: MouseInput;
+    /**
+     * The keyboard input controller used for camera movement.
+     */
+    protected readonly directionsInput: DirectionKeyboardInput;
+    /**
+     * Creates a new FreeCameraInput instance.
+     * @param keyboard The keyboard input controller to use for camera movement.
+     * @param camera The camera entity to control.
+     * @param options Optional configuration options for the controller.
+     */
+    constructor(keyboard: KeyboardInput, camera: Gg3dCameraEntity, options?: FreeCameraControllerOptions);
+    onSpawned(world: GgWorld<any, any>): Promise<void>;
+    onRemoved(): Promise<void>;
+}

package/dist/3d/entities/controllers/input/free-camera.controller.js

@@ -0,0 +1,102 @@
+"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.FreeCameraController = void 0;
+const rxjs_1 = require("rxjs");
+const mouse_input_1 = require("../../../../base/inputs/mouse.input");
+const point3_1 = require("../../../../base/math/point3");
+const point2_1 = require("../../../../base/math/point2");
+const quaternion_1 = require("../../../../base/math/quaternion");
+const direction_keyboard_input_1 = require("../../../../base/inputs/direction.keyboard-input");
+const gg_entity_1 = require("../../../../base/entities/gg-entity");
+/**
+ * A controller for a free-moving camera.
+ */
+class FreeCameraController extends gg_entity_1.GgEntity {
+    /**
+     * Creates a new FreeCameraInput instance.
+     * @param keyboard The keyboard input controller to use for camera movement.
+     * @param camera The camera entity to control.
+     * @param options Optional configuration options for the controller.
+     */
+    constructor(keyboard, camera, options = {
+        keymap: 'wasd',
+        movementOptions: { speed: 0.5 },
+        mouseOptions: {},
+    }) {
+        super();
+        this.keyboard = keyboard;
+        this.camera = camera;
+        this.options = options;
+        this.tickOrder = gg_entity_1.GGTickOrder.INPUT_CONTROLLERS;
+        this.mouseInput = new mouse_input_1.MouseInput(options.mouseOptions);
+        this.directionsInput = new direction_keyboard_input_1.DirectionKeyboardInput(keyboard, options.keymap);
+    }
+    onSpawned(world) {
+        const _super = Object.create(null, {
+            onSpawned: { get: () => super.onSpawned }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.onSpawned.call(this, world);
+            // Subscribe to keyboard input for movement controls
+            let controls = { direction: {}, rest: [] };
+            const keys = ['KeyE', 'KeyQ'];
+            if (this.camera.object3D.supportsFov) {
+                keys.push('KeyZ', 'KeyC');
+            }
+            this.directionsInput.output$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(d => {
+                controls.direction = d;
+            });
+            (0, rxjs_1.combineLatest)(keys.map(c => this.keyboard.bind(c)))
+                .pipe((0, rxjs_1.takeUntil)(this._onRemoved$))
+                .subscribe((d) => {
+                controls.rest = d;
+            });
+            // Subscribe to mouse input for camera rotation
+            let rotationDelta = { x: 0, y: 0 };
+            this.mouseInput.delta$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(delta => {
+                rotationDelta = point2_1.Pnt2.add(rotationDelta, delta);
+            });
+            // Setup updating camera position and rotation based on input
+            this.camera.tick$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(() => {
+                let translateVector = { x: 0, y: 0, z: 0 };
+                const [u, d, zo, zi] = controls.rest;
+                if (controls.direction.upDown !== undefined)
+                    translateVector.z = controls.direction.upDown ? -1 : 1;
+                if (controls.direction.leftRight !== undefined)
+                    translateVector.x = controls.direction.leftRight ? -1 : 1;
+                if (u != d)
+                    translateVector.y = d ? -1 : 1;
+                if (zo != zi)
+                    this.camera.object3D.fov += zo ? 1 : -1;
+                this.camera.position = point3_1.Pnt3.add(this.camera.position, point3_1.Pnt3.rot(point3_1.Pnt3.scalarMult(point3_1.Pnt3.norm(translateVector), this.options.movementOptions.speed), this.camera.rotation));
+                if (rotationDelta.x != 0 || rotationDelta.y != 0) {
+                    this.camera.rotation = quaternion_1.Qtrn.combineRotations(quaternion_1.Qtrn.fromAngle({ x: 0, y: 0, z: 1 }, -rotationDelta.x / 300), this.camera.rotation, quaternion_1.Qtrn.fromAngle({ x: 1, y: 0, z: 0 }, -rotationDelta.y / 300));
+                    rotationDelta = { x: 0, y: 0 };
+                }
+            });
+            // start input
+            yield this.mouseInput.start();
+            yield this.directionsInput.start();
+        });
+    }
+    onRemoved() {
+        const _super = Object.create(null, {
+            onRemoved: { get: () => super.onRemoved }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.onRemoved.call(this);
+            yield this.mouseInput.stop(true);
+            yield this.directionsInput.stop();
+        });
+    }
+}
+exports.FreeCameraController = FreeCameraController;

package/dist/3d/entities/gg-3d-entity.d.ts

@@ -1,14 +1,12 @@
-import { Subject } from 'rxjs';
 import { GgPositionable3dEntity } from './gg-positionable-3d-entity';
-import { ITickListener } from '../../base/entities/interfaces/i-tick-listener';
 import { Point3, Point4 } from '../../base/models/points';
 import { Gg3dWorld } from '../gg-3d-world';
 import { IGg3dBody, IGg3dObject } from '../interfaces';
-export declare class Gg3dEntity extends GgPositionable3dEntity implements ITickListener {
+import { GGTickOrder } from '../../base/entities/gg-entity';
+export declare class Gg3dEntity extends GgPositionable3dEntity {
     readonly object3D: IGg3dObject | null;
     readonly objectBody: IGg3dBody | null;
-    readonly tick$: Subject<[number, number]>;
-    readonly tickOrder = 750;
+    readonly tickOrder = GGTickOrder.OBJECTS_BINDING;
     get position(): Point3;
     set position(value: Point3);
     get rotation(): Point4;

package/dist/3d/entities/gg-3d-entity.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Gg3dEntity = void 0;
-const rxjs_1 = require("rxjs");
 const gg_positionable_3d_entity_1 = require("./gg-positionable-3d-entity");
+const gg_entity_1 = require("../../base/entities/gg-entity");
 class Gg3dEntity extends gg_positionable_3d_entity_1.GgPositionable3dEntity {
     constructor(object3D, objectBody = null) {
         super();
         this.object3D = object3D;
         this.objectBody = objectBody;
-        this.tick$ = new rxjs_1.Subject();
-        this.tickOrder = 750;
+        this.tickOrder = gg_entity_1.GGTickOrder.OBJECTS_BINDING;
         if (objectBody) {
             objectBody.entity = this;
             this.tick$.subscribe(() => {

package/dist/3d/entities/gg-3d-map-graph.entity.d.ts

@@ -1,8 +1,7 @@
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
 import { Point3, Point4 } from '../../base/models/points';
 import { Graph } from '../../base/data-structures/graph';
-import { GgEntity } from '../../base/entities/gg-entity';
-import { ITickListener } from '../../base/entities/interfaces/i-tick-listener';
+import { GgEntity, GGTickOrder } from '../../base/entities/gg-entity';
 import { GgPositionable3dEntity } from './gg-positionable-3d-entity';
 import { Gg3dWorld } from '../gg-3d-world';
 import { Gg3dEntity } from './gg-3d-entity';
@@ -23,10 +22,9 @@ export declare type Gg3dMapGraphEntityOptions = {
     loadDepth: number;
     inertia: number;
 };
-export declare class Gg3dMapGraphEntity extends GgEntity implements ITickListener {
+export declare class Gg3dMapGraphEntity extends GgEntity {
     readonly mapGraph: MapGraph;
-    readonly tick$: Subject<[number, number]>;
-    readonly tickOrder = 1500;
+    readonly tickOrder = GGTickOrder.POST_RENDERING;
     readonly loaderCursorEntity$: BehaviorSubject<GgPositionable3dEntity | null>;
     readonly loaded: Map<MapGraphNodeType, GgPositionable3dEntity[]>;
     private _initialLoadComplete$;

package/dist/3d/entities/gg-3d-map-graph.entity.js

@@ -69,8 +69,7 @@ class Gg3dMapGraphEntity extends gg_entity_1.GgEntity {
     constructor(mapGraph, options = {}) {
         super();
         this.mapGraph = mapGraph;
-        this.tick$ = new rxjs_1.Subject();
-        this.tickOrder = 1500;
+        this.tickOrder = gg_entity_1.GGTickOrder.POST_RENDERING;
         this.loaderCursorEntity$ = new rxjs_1.BehaviorSubject(null);
         this.loaded = new Map();
         this._initialLoadComplete$ = new rxjs_1.BehaviorSubject(false);

package/dist/3d/inputs/car-keyboard.input.d.ts

@@ -0,0 +1,25 @@
+import { BehaviorSubject } from 'rxjs';
+import { Input } from '../../base/inputs/input';
+import { KeyboardInput } from '../../base/inputs/keyboard.input';
+import { Gg3dRaycastVehicleEntity } from '../entities/gg-3d-raycast-vehicle.entity';
+import { DirectionKeyboardInput, DirectionKeyboardKeymap } from '../../base/inputs/direction.keyboard-input';
+export declare type CarKeyboardControllerOptions = {
+    keymap: DirectionKeyboardKeymap;
+    gearUpDownKeys: [string, string];
+};
+export declare class CarKeyboardInput extends Input {
+    protected readonly keyboard: KeyboardInput;
+    protected readonly options: CarKeyboardControllerOptions;
+    protected readonly directionsInput: DirectionKeyboardInput;
+    protected readonly x$: BehaviorSubject<number>;
+    protected readonly y$: BehaviorSubject<number>;
+    protected lastX: number;
+    protected readonly car$: BehaviorSubject<Gg3dRaycastVehicleEntity>;
+    set car(value: Gg3dRaycastVehicleEntity);
+    get car(): Gg3dRaycastVehicleEntity;
+    switchingGearsEnabled: boolean;
+    pairTickerPipe: import("rxjs").UnaryFunction<import("rxjs").Observable<number>, import("rxjs").Observable<number>>;
+    constructor(keyboard: KeyboardInput, car: Gg3dRaycastVehicleEntity, options?: CarKeyboardControllerOptions);
+    protected startInternal(): Promise<void>;
+    protected stopInternal(): Promise<void>;
+}

package/dist/3d/inputs/car-keyboard.input.js

@@ -0,0 +1,100 @@
+"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.CarKeyboardInput = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const input_1 = require("../../base/inputs/input");
+const direction_keyboard_input_1 = require("../../base/inputs/direction.keyboard-input");
+// TODO pass as settings
+// TODO smooth y?
+const TICKER_INTERVAL = 16;
+const TICKER_MAX_STEPS = 10;
+class CarKeyboardInput extends input_1.Input {
+    constructor(keyboard, car, options = { keymap: 'arrows', gearUpDownKeys: ['KeyA', 'KeyZ'] }) {
+        super();
+        this.keyboard = keyboard;
+        this.options = options;
+        // emits values -1 - 1; -1 = full turn left; 1 = full turn right
+        this.x$ = new rxjs_1.BehaviorSubject(0);
+        // emits values -1 - 1; -1 = full brake; 1 = full acceleration
+        this.y$ = new rxjs_1.BehaviorSubject(0);
+        this.lastX = 0;
+        this.car$ = new rxjs_1.BehaviorSubject(null);
+        this.switchingGearsEnabled = true;
+        this.pairTickerPipe = (0, rxjs_1.pipe)((0, operators_1.startWith)(0), (0, operators_1.pairwise)(), (0, operators_1.map)(([beforeValue, afterValue]) => [this.lastX, afterValue]), (0, operators_1.switchMap)(([beforeValue, afterValue]) => (0, rxjs_1.interval)(TICKER_INTERVAL).pipe((0, operators_1.take)(TICKER_MAX_STEPS), (0, operators_1.map)(count => ++count), (0, operators_1.map)(count => beforeValue * ((TICKER_MAX_STEPS - count) / TICKER_MAX_STEPS) + afterValue * (count / TICKER_MAX_STEPS)), (0, operators_1.tap)(x => {
+            this.lastX = x;
+        }))));
+        this.car$.next(car);
+        this.directionsInput = new direction_keyboard_input_1.DirectionKeyboardInput(keyboard, options.keymap);
+    }
+    set car(value) {
+        this.car$.next(value);
+    }
+    get car() {
+        return this.car$.getValue();
+    }
+    startInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let moveDirection = {};
+            this.keyboard
+                .bind(this.options.gearUpDownKeys[0])
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, rxjs_1.filter)(x => this.switchingGearsEnabled && !!x))
+                .subscribe(() => {
+                if (this.car$.getValue() &&
+                    (!this.car$.getValue().carProperties.transmission.isAuto || this.car$.getValue().gear <= 0)) {
+                    this.car$.getValue().gear++;
+                }
+            });
+            this.keyboard
+                .bind(this.options.gearUpDownKeys[1])
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, rxjs_1.filter)(x => this.switchingGearsEnabled && !!x))
+                .subscribe(() => {
+                if (this.car$.getValue().carProperties.transmission.isAuto && this.car.gear > 1) {
+                    this.car$.getValue().gear = 0;
+                }
+                else {
+                    this.car$.getValue().gear--;
+                }
+            });
+            this.directionsInput.output$.pipe((0, rxjs_1.takeUntil)(this.stop$)).subscribe(d => {
+                moveDirection = d;
+            });
+            this.car$
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.switchMap)(c => c.tick$), (0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.map)(() => {
+                const direction = [0, 0];
+                if (moveDirection.leftRight !== undefined)
+                    direction[0] = moveDirection.leftRight ? -1 : 1;
+                if (moveDirection.upDown !== undefined)
+                    direction[1] = moveDirection.upDown ? 1 : -1;
+                return direction;
+            }))
+                .subscribe(([x, y]) => {
+                this.x$.next(x);
+                this.y$.next(y);
+            });
+            (0, rxjs_1.combineLatest)([
+                this.x$.pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.distinctUntilChanged)(), this.pairTickerPipe),
+                this.y$.pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.distinctUntilChanged)()),
+            ]).subscribe(([x, y]) => {
+                this.car$.getValue().setXAxisControlValue(x);
+                this.car$.getValue().setYAxisControlValue(y);
+            });
+            yield this.directionsInput.start();
+        });
+    }
+    stopInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.directionsInput.stop();
+        });
+    }
+}
+exports.CarKeyboardInput = CarKeyboardInput;