@gg-web-engine/core 0.0.1

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

@@ -0,0 +1,164 @@
+"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.Gg3dMapGraphEntity = exports.MapGraph = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const graph_1 = require("../../base/data-structures/graph");
+const gg_entity_1 = require("../../base/entities/gg-entity");
+class MapGraph extends graph_1.Graph {
+    static fromMapArray(array) {
+        const root = new MapGraph(array[0]);
+        let tail = root;
+        for (let i = 1; i < array.length; i++) {
+            const newTail = new MapGraph(array[i]);
+            tail.addAdjacent(newTail);
+            tail = newTail;
+        }
+        return root;
+    }
+    static fromMapSquareGrid(grid) {
+        const nodes = grid.map(sgrid => sgrid.map(item => new MapGraph(item)));
+        // bind them
+        for (let j = 0; j < nodes.length; j++) {
+            for (let i = 0; i < nodes.length; i++) {
+                if (i > 0) {
+                    nodes[j][i].addAdjacent(nodes[j][i - 1]);
+                }
+                if (j > 0) {
+                    nodes[j][i].addAdjacent(nodes[j - 1][i]);
+                }
+            }
+        }
+        return nodes[0][0];
+    }
+    getNearestDummy(thisNodes, cursor) {
+        let min = Infinity;
+        let node = this;
+        // TODO should be heavily optimized with kd-tree-javascript, but building spatial index takes too much time. Serialize to file?
+        thisNodes.forEach(n => {
+            let dist = Math.sqrt(Math.pow(cursor.x - n.data.position.x, 2) +
+                Math.pow(cursor.y - n.data.position.y, 2) +
+                Math.pow(cursor.z - n.data.position.z, 2));
+            if (dist < min) {
+                min = dist;
+                node = n;
+            }
+        });
+        return node;
+    }
+    // TODO return iterable?
+    nodes() {
+        return Array.from(this.walkRead(-1));
+    }
+}
+exports.MapGraph = MapGraph;
+const defaultOptions = {
+    loadDepth: 5,
+    inertia: 0,
+};
+class Gg3dMapGraphEntity extends gg_entity_1.GgEntity {
+    constructor(mapGraph, options = {}) {
+        super();
+        this.mapGraph = mapGraph;
+        this.tick$ = new rxjs_1.Subject();
+        this.tickOrder = 1500;
+        this.loaderCursorEntity$ = new rxjs_1.BehaviorSubject(null);
+        this.loaded = new Map();
+        this._initialLoadComplete$ = new rxjs_1.BehaviorSubject(false);
+        this._nearestDummy$ = new rxjs_1.BehaviorSubject(null);
+        this._chunkLoaded$ = new rxjs_1.Subject();
+        this._world = null;
+        this.options = Object.assign(Object.assign({}, defaultOptions), options);
+        this.mapGraphNodes = mapGraph.nodes();
+    }
+    get initialLoadComplete$() {
+        return this._initialLoadComplete$.asObservable();
+    }
+    get nearestDummy() {
+        return this._nearestDummy$.getValue();
+    }
+    get chunkLoaded$() {
+        return this._chunkLoaded$.asObservable();
+    }
+    get world() {
+        return this._world;
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        // TODO takeUntil removed from world?
+        this.loaderCursorEntity$
+            .pipe((0, rxjs_1.switchMap)(entity => entity
+            ? this.tick$.pipe((0, rxjs_1.startWith)(null), // map will perform initial loading even if world not started yet. Handy to preload map
+            (0, operators_1.throttleTime)(1000), (0, operators_1.map)(() => entity.position))
+            : rxjs_1.NEVER), (0, operators_1.map)(pos => this.mapGraph.getNearestDummy(this.mapGraphNodes, pos)), (0, operators_1.tap)(node => this._nearestDummy$.next(node)), (0, operators_1.distinctUntilChanged)())
+            .subscribe(currentChunk => {
+            let haveToBeLoaded = new Set();
+            let canBeLoaded;
+            if (this.options.inertia > 0) {
+                canBeLoaded = new Set();
+                const nodes = currentChunk.walkReadPreserveDepth(this.options.loadDepth + this.options.inertia);
+                for (let distance = 0; distance < nodes.length; distance++) {
+                    nodes[distance].forEach(node => canBeLoaded.add(node.data));
+                    if (distance <= this.options.loadDepth) {
+                        nodes[distance].forEach(node => haveToBeLoaded.add(node.data));
+                    }
+                }
+            }
+            else {
+                currentChunk.walkRead(this.options.loadDepth).forEach(node => haveToBeLoaded.add(node.data));
+                canBeLoaded = haveToBeLoaded;
+            }
+            for (const loadedNode of this.loaded.keys()) {
+                if (!canBeLoaded.has(loadedNode)) {
+                    this.disposeChunk(loadedNode);
+                }
+                else {
+                    haveToBeLoaded.delete(loadedNode);
+                }
+            }
+            Promise.all(Array.from(haveToBeLoaded.keys()).map(n => this.loadChunk(n))).then(() => this._initialLoadComplete$.next(true));
+        });
+    }
+    onRemoved() {
+        super.onRemoved();
+        this.loaderCursorEntity$.next(null);
+    }
+    loadChunk(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loaded = yield this.world.loader.loadGgGlb(node.path, Object.assign({ position: node.position, rotation: node.rotation || { x: 0, y: 0, z: 0, w: 1 } }, node.loadOptions));
+            const entities = [
+                ...loaded.entities,
+                ...(loaded.props || [])
+                    .map(p => p.entities)
+                    .reduce((p, c) => {
+                    p.push(...c);
+                    return p;
+                }, []),
+            ];
+            this.loaded.set(node, entities);
+            this.addChildren(...entities);
+            this._chunkLoaded$.next([
+                loaded,
+                { position: node.position, rotation: node.rotation || { x: 0, y: 0, z: 0, w: 1 } },
+            ]);
+            return entities;
+        });
+    }
+    disposeChunk(node) {
+        if (!this.loaded.has(node)) {
+            return;
+        }
+        this.removeChildren(this.loaded.get(node), true);
+        this.loaded.delete(node);
+    }
+}
+exports.Gg3dMapGraphEntity = Gg3dMapGraphEntity;

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

@@ -0,0 +1,107 @@
+import { Point3, Point4 } from '../../base/models/points';
+import { Gg3dEntity } from './gg-3d-entity';
+import { IGg3dBody, IGg3dObject, IGg3dRaycastVehicle } from '../interfaces';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Gg3dWorld } from '../gg-3d-world';
+import { AxisDirection3 } from '../../base/models/axis-directions';
+export declare type WheelOptions = {
+    tyre_width: number;
+    tyre_radius: number;
+    wheelObject?: IGg3dObject;
+    wheelObjectDirection?: AxisDirection3;
+    isLeft: boolean;
+    isFront: boolean;
+    position: Point3;
+    frictionSlip: number;
+    rollInfluence: number;
+    maxTravel: number;
+};
+export declare type SuspensionOptions = {
+    stiffness: number;
+    damping: number;
+    compression: number;
+    restLength: number;
+};
+export declare type CarProperties = {
+    typeOfDrive: 'RWD' | 'FWD' | '4WD';
+    wheelOptions: WheelOptions[];
+    mpsToRpmFactor?: number;
+    engine: {
+        minRpm: number;
+        maxRpm: number;
+        torques: {
+            rpm: number;
+            torque: number;
+        }[];
+        maxRpmIncreasePerSecond: number;
+        maxRpmDecreasePerSecond: number;
+    };
+    transmission: {
+        isAuto: boolean;
+        reverseGearRatio: number;
+        gearRatios: number[];
+        drivelineEfficiency: number;
+        finalDriveRatio: number;
+        upShifts: number[];
+    };
+    suspension: SuspensionOptions;
+};
+export declare class Gg3dRaycastVehicleEntity extends Gg3dEntity {
+    readonly carProperties: CarProperties;
+    readonly chassis3D: IGg3dObject | null;
+    readonly chassisBody: IGg3dRaycastVehicle;
+    readonly wheelObject: IGg3dObject | null;
+    readonly wheelObjectDirection: AxisDirection3;
+    private readonly wheels;
+    private readonly wheelLocalRotation;
+    private readonly wheelLocalTranslation;
+    protected readonly frontWheelsIndices: number[];
+    protected readonly tractionWheelIndices: number[];
+    readonly tractionWheelRadius: number;
+    protected get dynamicTractionWheelRadius(): number;
+    get engineTorque(): number;
+    get transmissionGearRatio(): number;
+    protected get mpsToRpm(): number;
+    getSpeed(): number;
+    calculateRpmFromCarSpeed(): number;
+    getDisplaySpeed(units?: 'ms' | 'kmh' | 'mph'): number;
+    protected readonly _rpm$: BehaviorSubject<number>;
+    get engineRpm$(): Observable<number>;
+    get engineRpm(): number;
+    protected get tractionForce(): number;
+    private readonly _maxSteerVal;
+    private readonly brakingForce;
+    get maxSteerVal(): number;
+    private getMaxStableSteerVal;
+    private _tailLightsOn;
+    get tailLightsOn(): boolean;
+    protected setTailLightsOn(value: boolean): void;
+    protected _acceleration$: BehaviorSubject<number>;
+    protected get acceleration(): number;
+    get acceleration$(): Observable<number>;
+    protected set acceleration(value: number);
+    protected brake$: BehaviorSubject<number>;
+    protected get brake(): number;
+    protected set brake(value: number);
+    private _gear;
+    private _gear$;
+    get gear(): number;
+    get gear$(): Observable<number>;
+    set gear(value: number);
+    set isHonking(value: boolean);
+    private _steeringValue;
+    get steeringValue(): number;
+    protected setSteeringValue(value: number): void;
+    /** car mesh and physics body direction has to be pointing: y front, z up*/
+    constructor(carProperties: CarProperties, chassis3D: IGg3dObject | null, chassisBody: IGg3dRaycastVehicle, wheelObject?: IGg3dObject | null, wheelObjectDirection?: AxisDirection3);
+    onSpawned(world: Gg3dWorld): void;
+    protected runTransformBinding(objectBody: IGg3dBody, object3D: IGg3dObject): void;
+    private get isTouchingGround();
+    private updateEngine;
+    resetTo(options?: {
+        position?: Point3;
+        rotation?: Point4;
+    }): void;
+    setXAxisControlValue(value: number): void;
+    setYAxisControlValue(value: number): void;
+}

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

@@ -0,0 +1,372 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg3dRaycastVehicleEntity = void 0;
+const gg_3d_entity_1 = require("./gg-3d-entity");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const box_1 = require("../../base/math/box");
+const quaternion_1 = require("../../base/math/quaternion");
+const point3_1 = require("../../base/math/point3");
+class Gg3dRaycastVehicleEntity extends gg_3d_entity_1.Gg3dEntity {
+    /** car mesh and physics body direction has to be pointing: y front, z up*/
+    constructor(carProperties, chassis3D, chassisBody, wheelObject = null, wheelObjectDirection = 'x') {
+        super(chassis3D, chassisBody);
+        this.carProperties = carProperties;
+        this.chassis3D = chassis3D;
+        this.chassisBody = chassisBody;
+        this.wheelObject = wheelObject;
+        this.wheelObjectDirection = wheelObjectDirection;
+        this.wheels = [];
+        this.wheelLocalRotation = [];
+        this.wheelLocalTranslation = [];
+        this.frontWheelsIndices = [];
+        this.tractionWheelIndices = [];
+        this._rpm$ = new rxjs_1.BehaviorSubject(this.carProperties.engine.minRpm);
+        // TODO should be parameters
+        this._maxSteerVal = 0.35;
+        this.brakingForce = 300;
+        this._tailLightsOn = false;
+        // 0..1
+        this._acceleration$ = new rxjs_1.BehaviorSubject(0);
+        // 0..1
+        this.brake$ = new rxjs_1.BehaviorSubject(0);
+        this._gear = 0;
+        this._gear$ = new rxjs_1.BehaviorSubject(0);
+        this._steeringValue = 0;
+        this.carProperties.wheelOptions.forEach((x, i) => {
+            if (x.isFront) {
+                this.frontWheelsIndices.push(i);
+            }
+            if (x.isFront && this.carProperties.typeOfDrive != 'RWD') {
+                this.tractionWheelIndices.push(i);
+            }
+            if (!x.isFront && this.carProperties.typeOfDrive != 'FWD') {
+                this.tractionWheelIndices.push(i);
+            }
+        });
+        this.tractionWheelRadius = this.carProperties.wheelOptions[this.tractionWheelIndices[0]].tyre_radius;
+        // TODO perform this in a parent application
+        // chassisBody.setDamping(0.02, 0.02); // TODO imitates air resistance. calculate from properties
+        this.carProperties.wheelOptions.forEach(wheelOpts => {
+            this.chassisBody.addWheel(wheelOpts, this.carProperties.suspension);
+        });
+        if (this.wheelObject) {
+            for (let i = 0; i < this.carProperties.wheelOptions.length; i++) {
+                const options = this.carProperties.wheelOptions[i];
+                if (!options.wheelObject && !this.wheelObject) {
+                    this.wheels.push(null);
+                    this.wheelLocalRotation.push(null);
+                    continue;
+                }
+                const entity = options.wheelObject || this.wheelObject.clone();
+                const localTranslation = { x: options.tyre_width * (options.isLeft ? 1 : -1), y: 0, z: 0 };
+                const boundingBox = box_1.Box.expandByPoint(entity.getBoundings(), { x: 0, y: 0, z: 0 });
+                const scale = { x: 0, y: 0, z: 0 };
+                for (const dir of ['x', 'y', 'z']) {
+                    const wheelObjectDirection = options.wheelObjectDirection || this.wheelObjectDirection;
+                    const isNormal = wheelObjectDirection.includes(dir);
+                    scale[dir] = isNormal
+                        ? options.tyre_width / (boundingBox.max[dir] - boundingBox.min[dir])
+                        : (options.tyre_radius * 2) / (boundingBox.max[dir] - boundingBox.min[dir]);
+                    if (isNormal) {
+                        localTranslation.x +=
+                            (wheelObjectDirection.startsWith('-') ? boundingBox.max[dir] : boundingBox.min[dir]) *
+                                scale[dir] *
+                                (options.isLeft ? 1 : -1);
+                    }
+                }
+                entity.scale = scale;
+                const direction = options.wheelObjectDirection || this.wheelObjectDirection;
+                const flip = direction.includes('-') ? !options.isLeft : options.isLeft;
+                let localRotation = null;
+                if (direction.includes('x')) {
+                    // rotate PI around Z if opposite position (x is correct for right wheel, -x is correct for left wheel)
+                    if (flip)
+                        localRotation = { x: 0, y: 0, z: 1, w: 0 };
+                }
+                else if (direction.includes('y')) {
+                    // rotate PI/2 around Z
+                    localRotation = { x: 0, y: 0, z: 0.707107 * (flip ? 1 : -1), w: 0.707107 };
+                }
+                else if (direction.includes('z')) {
+                    // rotate PI/2 around Y
+                    localRotation = { x: 0, y: 0.707107 * (flip ? -1 : 1), z: 0, w: 0.707107 };
+                }
+                this.wheelLocalTranslation.push(localTranslation);
+                this.wheelLocalRotation.push(localRotation);
+                this.wheels.push(new gg_3d_entity_1.Gg3dEntity(entity));
+            }
+        }
+        this._children = [...this.wheels.filter(x => !!x)];
+        this.chassisBody.entity = this;
+    }
+    get dynamicTractionWheelRadius() {
+        // The dynamic wheel radius [m] is the radius of the wheel when the vehicle is in motion. It is smaller than the static wheel radius rws because the tire is slightly compressed during vehicle motion.
+        return 0.98 * this.tractionWheelRadius;
+    }
+    get engineTorque() {
+        const currentRPM = this.engineRpm;
+        const maxMapTorque = this.carProperties.engine.torques[this.carProperties.engine.torques.length - 1].rpm;
+        if (currentRPM >= maxMapTorque) {
+            return (Math.pow(Math.max(0, 1 - (currentRPM - maxMapTorque) / (this.carProperties.engine.maxRpm - maxMapTorque)), 2) *
+                this.carProperties.engine.torques[this.carProperties.engine.torques.length - 1].torque);
+        }
+        let index = 0;
+        let factor = 0;
+        for (let i = 0; i < this.carProperties.engine.torques.length; i++) {
+            if (this.carProperties.engine.torques[i].rpm < currentRPM) {
+                index = i;
+                continue;
+            }
+            factor = Math.max(0, (currentRPM - this.carProperties.engine.torques[index].rpm) /
+                (this.carProperties.engine.torques[index + 1].rpm - this.carProperties.engine.torques[index].rpm));
+            break;
+        }
+        if (factor === 0) {
+            return this.carProperties.engine.torques[index].torque;
+        }
+        else {
+            return (this.carProperties.engine.torques[index].torque +
+                factor * (this.carProperties.engine.torques[index + 1].torque - this.carProperties.engine.torques[index].torque));
+        }
+    }
+    get transmissionGearRatio() {
+        if (this._gear == -1) {
+            return this.carProperties.transmission.reverseGearRatio;
+        }
+        return this.carProperties.transmission.gearRatios[this._gear - 1] || 0;
+    }
+    get mpsToRpm() {
+        return (this.carProperties.mpsToRpmFactor ||
+            (30 * this.carProperties.transmission.finalDriveRatio) / (Math.PI * this.dynamicTractionWheelRadius));
+    }
+    // m/s
+    getSpeed() {
+        return this.chassisBody.wheelSpeed;
+    }
+    calculateRpmFromCarSpeed() {
+        return this.getSpeed() * this.mpsToRpm * this.transmissionGearRatio;
+    }
+    // TODO remove from here, end application should do this work
+    getDisplaySpeed(units = 'ms') {
+        if (units === 'ms') {
+            return this.getSpeed();
+        }
+        const kmh = this.getSpeed() * 3.6;
+        if (units === 'mph') {
+            return kmh * 0.621371192;
+        }
+        return kmh;
+    }
+    get engineRpm$() {
+        return this._rpm$.asObservable();
+    }
+    get engineRpm() {
+        return this._rpm$.getValue();
+    }
+    get tractionForce() {
+        return ((this.engineTorque *
+            this.transmissionGearRatio *
+            this.carProperties.transmission.finalDriveRatio *
+            this.carProperties.transmission.drivelineEfficiency) /
+            this.dynamicTractionWheelRadius);
+    }
+    get maxSteerVal() {
+        return this._maxSteerVal;
+    }
+    getMaxStableSteerVal() {
+        const speed = this.getSpeed() * 3.6;
+        if (speed < 40) {
+            return this.maxSteerVal;
+        }
+        const mult = Math.pow((340 - speed) / 300, 2);
+        return this.maxSteerVal * Math.max(mult, 0.06);
+    }
+    get tailLightsOn() {
+        return this._tailLightsOn;
+    }
+    setTailLightsOn(value) {
+        if (this._tailLightsOn != value) {
+            this._tailLightsOn = value;
+        }
+    }
+    get acceleration() {
+        return this._acceleration$.getValue();
+    }
+    get acceleration$() {
+        return this._acceleration$.asObservable();
+    }
+    set acceleration(value) {
+        this._acceleration$.next(value);
+    }
+    get brake() {
+        return this.brake$.getValue();
+    }
+    set brake(value) {
+        this.brake$.next(value);
+    }
+    get gear() {
+        return this._gear;
+    }
+    get gear$() {
+        return this._gear$.asObservable();
+    }
+    set gear(value) {
+        value = Math.max(-1, Math.min(this.carProperties.transmission.gearRatios.length, value));
+        if (value === this._gear) {
+            return;
+        }
+        this._gear = value;
+        this._gear$.next(value);
+    }
+    // TODO remove
+    set isHonking(value) { }
+    get steeringValue() {
+        return this._steeringValue;
+    }
+    setSteeringValue(value) {
+        if (this._steeringValue != value) {
+            this._steeringValue = value;
+        }
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.tick$.subscribe(([_, delta]) => {
+            this.updateEngine(delta);
+            if (this.isTouchingGround) {
+                // TODO 1 - R (1000 rpm) quick switch with acceleration pedal should have the same speed as without acceleration pedal
+                let force;
+                let brakeForce = this.brake;
+                const calculatedRpm = this.calculateRpmFromCarSpeed();
+                if (this.gear !== 0 && calculatedRpm > this.carProperties.engine.maxRpm) {
+                    // engine brake, this is related to clutch, better clutch condition - bigger force
+                    force = this.gear > 0 ? -12000 : 12000;
+                }
+                else {
+                    force =
+                        this.acceleration > 0
+                            ? this.tractionForce * this.acceleration // apply torque
+                            : 0.5 * (this.carProperties.engine.minRpm - calculatedRpm) * (this.gear > 0 ? 1 : -1); // released, use engine brake
+                    // this functionality makes car stay still (parking gear) when speed is low
+                    const speedThreshold = 3;
+                    if (Math.abs(this.getSpeed()) < speedThreshold && (this.gear == 0 || this.acceleration == 0)) {
+                        brakeForce = Math.max(brakeForce, (0.3 * (speedThreshold - this.getSpeed()) * this.brakingForce) / speedThreshold);
+                        force = 0;
+                    }
+                }
+                const forcePerWheel = force / this.tractionWheelIndices.length;
+                this.tractionWheelIndices.forEach(index => this.chassisBody.applyEngineForce(index, forcePerWheel));
+                this.wheels.forEach((w, i) => this.chassisBody.applyBrake(i, brakeForce));
+            }
+        });
+        if (this.carProperties.transmission.isAuto) {
+            this.tick$
+                .pipe((0, operators_1.throttleTime)(50), (0, rxjs_1.filter)(() => this.isTouchingGround))
+                .subscribe(() => {
+                let gear = this.gear;
+                let upshifted = false;
+                if (gear > 0) {
+                    let rpm = this.engineRpm;
+                    while (rpm >= this.carProperties.transmission.upShifts[gear - 1]) {
+                        rpm *=
+                            this.carProperties.transmission.gearRatios[gear] / this.carProperties.transmission.gearRatios[gear - 1];
+                        gear++;
+                        upshifted = true;
+                    }
+                    if (!upshifted) {
+                        while (gear > 1) {
+                            rpm *=
+                                this.carProperties.transmission.gearRatios[gear - 2] /
+                                    this.carProperties.transmission.gearRatios[gear - 1];
+                            if (rpm > this.carProperties.transmission.upShifts[gear - 2]) {
+                                break;
+                            }
+                            gear--;
+                        }
+                    }
+                    this.gear = gear;
+                }
+            });
+        }
+    }
+    runTransformBinding(objectBody, object3D) {
+        super.runTransformBinding(objectBody, object3D);
+        const carRotation = this.rotation;
+        for (const [i, wheel] of (this.wheels || []).entries()) {
+            if (!wheel) {
+                continue;
+            }
+            let { position, rotation } = this.chassisBody.getWheelTransform(i);
+            if (this.wheelLocalRotation[i]) {
+                rotation = quaternion_1.Qtrn.combineRotations(rotation, this.wheelLocalRotation[i]);
+            }
+            position = point3_1.Pnt3.add(position, point3_1.Pnt3.rot(this.wheelLocalTranslation[i], carRotation));
+            wheel.position = position;
+            wheel.rotation = rotation;
+        }
+    }
+    get isTouchingGround() {
+        // is at least one traction wheel touches the ground
+        return this.tractionWheelIndices
+            .map(i => this.chassisBody.isWheelTouchesGround(i))
+            .reduce((prev, cur) => cur || prev, false);
+    }
+    updateEngine(delta) {
+        delta = delta / 1000; // ms -> s
+        const acceleration = this._acceleration$.getValue();
+        let rpm = this.engineRpm;
+        // TODO here I will take perioud between gears and drift into account someday :)
+        const gripKoeff = this.gear === 0 || !this.isTouchingGround ? 0 : 1;
+        if (gripKoeff == 0) {
+            rpm +=
+                (acceleration * 2 - 1) *
+                    (acceleration > 0.5
+                        ? this.carProperties.engine.maxRpmIncreasePerSecond
+                        : this.carProperties.engine.maxRpmDecreasePerSecond) *
+                    delta;
+        }
+        else {
+            const rpmFromSpeed = this.calculateRpmFromCarSpeed();
+            if (rpmFromSpeed > rpm) {
+                rpm = Math.min(rpmFromSpeed, rpm + this.carProperties.engine.maxRpmIncreasePerSecond * delta);
+            }
+            else {
+                rpm = Math.max(rpmFromSpeed, rpm - this.carProperties.engine.maxRpmDecreasePerSecond * delta);
+            }
+        }
+        this._rpm$.next(Math.max(this.carProperties.engine.minRpm, Math.min(this.carProperties.engine.maxRpm, rpm)));
+    }
+    // TODO delete and let game application do all the steps
+    resetTo(options = {}) {
+        this.chassisBody.resetMotion();
+        this.chassisBody.resetSuspension();
+        if (options.position) {
+            this.position = options.position;
+        }
+        if (options.rotation) {
+            this.rotation = options.rotation;
+        }
+        this._steeringValue = 0;
+        this.gear = 0;
+        this._rpm$.next(this.carProperties.engine.minRpm);
+    }
+    // TODO refactor: control has to be in control service, here we receive separately braking, acceleration, steering
+    setXAxisControlValue(value) {
+        const steering = this.getMaxStableSteerVal() * value;
+        this.frontWheelsIndices.forEach(index => this.chassisBody.setSteering(index, -steering));
+        this.setSteeringValue(-steering);
+    }
+    // TODO refactor: control has to be in control service, here we receive separately braking, acceleration, steering
+    setYAxisControlValue(value) {
+        if (value > 0) {
+            this.acceleration = value;
+            this.brake = 0;
+        }
+        else {
+            this.acceleration = 0;
+            this.brake = -this.brakingForce * value;
+        }
+        this.setTailLightsOn(value < 0);
+    }
+}
+exports.Gg3dRaycastVehicleEntity = Gg3dRaycastVehicleEntity;

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

@@ -0,0 +1,10 @@
+import { IGg3dTrigger } from '../interfaces';
+import { Gg3dEntity } from './gg-3d-entity';
+import { Observable } from 'rxjs';
+import { GgPositionable3dEntity } from './gg-positionable-3d-entity';
+export declare class Gg3dTriggerEntity extends Gg3dEntity {
+    readonly objectBody: IGg3dTrigger;
+    get onEntityEntered(): Observable<GgPositionable3dEntity>;
+    get onEntityLeft(): Observable<GgPositionable3dEntity | null>;
+    constructor(objectBody: IGg3dTrigger);
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gg3dTriggerEntity = void 0;
+const gg_3d_entity_1 = require("./gg-3d-entity");
+class Gg3dTriggerEntity extends gg_3d_entity_1.Gg3dEntity {
+    constructor(objectBody) {
+        super(null, objectBody);
+        this.objectBody = objectBody;
+        this.tick$.subscribe(() => {
+            this.objectBody.checkOverlaps();
+        });
+        this.objectBody.entity = this;
+    }
+    get onEntityEntered() {
+        return this.objectBody.onEntityEntered;
+    }
+    get onEntityLeft() {
+        return this.objectBody.onEntityLeft;
+    }
+}
+exports.Gg3dTriggerEntity = Gg3dTriggerEntity;

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

@@ -0,0 +1,11 @@
+import { Point3, Point4 } from '../../base/models/points';
+import { Observable } from 'rxjs';
+import { GgPositionableEntity } from '../../base/entities/gg-positionable-entity';
+export declare abstract class GgPositionable3dEntity extends GgPositionableEntity<Point3, Point4> {
+    getDefaultPosition(): Point3;
+    getDefaultRotation(): Point4;
+    getDefaultScale(): Point3;
+    get euler$(): Observable<Point3>;
+    get euler(): Point3;
+    set euler(value: Point3);
+}