@gg-web-engine/core 0.0.24 → 0.0.28

package/dist/2d/components/physics/i-rigid-body-2d.component.d.ts

@@ -1,4 +1,5 @@
 import { IRigidBodyComponent, Point2 } from '../../../base';
 import { IPhysicsWorld2dComponent } from './i-physics-world-2d.component';
 export interface IRigidBody2dComponent<PW extends IPhysicsWorld2dComponent = IPhysicsWorld2dComponent> extends IRigidBodyComponent<Point2, number, PW> {
+    angularVelocity: number;
 }

package/dist/2d/gg-2d-world.d.ts

@@ -7,8 +7,7 @@ import { Renderer2dEntity } from './entities/renderer-2d.entity';
 export declare class Gg2dWorld<V extends IVisualScene2dComponent = IVisualScene2dComponent, P extends IPhysicsWorld2dComponent = IPhysicsWorld2dComponent> extends GgWorld<Point2, number, V, P> {
     readonly visualScene: V;
     readonly physicsWorld: P;
-    protected readonly consoleEnabled: boolean;
-    constructor(visualScene: V, physicsWorld: P, consoleEnabled?: boolean);
+    constructor(visualScene: V, physicsWorld: P);
     addPrimitiveRigidBody(descr: BodyShape2DDescriptor, position?: Point2, rotation?: number): Entity2d<V, P>;
     addRenderer(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions>): Renderer2dEntity;
 }

package/dist/2d/gg-2d-world.js

@@ -11,13 +11,12 @@ import { GgWorld, Pnt2 } from '../base';
 import { Entity2d } from './entities/entity-2d';
 import { Renderer2dEntity } from './entities/renderer-2d.entity';
 export class Gg2dWorld extends GgWorld {
-    constructor(visualScene, physicsWorld, consoleEnabled = false) {
-        super(visualScene, physicsWorld, consoleEnabled);
+    constructor(visualScene, physicsWorld) {
+        super(visualScene, physicsWorld);
         this.visualScene = visualScene;
         this.physicsWorld = physicsWorld;
-        this.consoleEnabled = consoleEnabled;
-        if (consoleEnabled) {
-            this.registerConsoleCommand('ph_gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
+        if (window.ggstatic) {
+            window.ggstatic.registerConsoleCommand(this, 'ph_gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
                 if (args.length == 1) {
                     args = ['0', args[0]]; // mean Y axis
                 }

package/dist/3d/components/physics/i-raycast-vehicle.component.d.ts

@@ -1,6 +1,5 @@
-import { AxisDirection3, Point3, Point4 } from '../../../base';
+import { Point3, Point4 } from '../../../base';
 import { IRigidBody3dComponent } from './i-rigid-body-3d.component';
-import { IDisplayObject3dComponent } from '../rendering/i-display-object-3d.component';
 import { IPhysicsWorld3dComponent } from './i-physics-world-3d.component';
 export declare type SuspensionOptions = {
     stiffness: number;
@@ -9,12 +8,10 @@ export declare type SuspensionOptions = {
     restLength: number;
 };
 export declare type WheelOptions = {
-    tyre_width: number;
-    tyre_radius: number;
-    wheelObject?: IDisplayObject3dComponent;
-    wheelObjectDirection?: AxisDirection3;
     isLeft: boolean;
     isFront: boolean;
+    tyreWidth: number;
+    tyreRadius: number;
     position: Point3;
     frictionSlip: number;
     rollInfluence: number;

package/dist/3d/components/physics/i-rigid-body-3d.component.d.ts

@@ -1,4 +1,5 @@
 import { IRigidBodyComponent, Point3, Point4 } from '../../../base';
 import { IPhysicsWorld3dComponent } from './i-physics-world-3d.component';
 export interface IRigidBody3dComponent<PW extends IPhysicsWorld3dComponent = IPhysicsWorld3dComponent> extends IRigidBodyComponent<Point3, Point4, PW> {
+    angularVelocity: Point3;
 }

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

@@ -1,23 +1,21 @@
-import { BehaviorSubject } from 'rxjs';
-import { DirectionKeyboardInput, DirectionKeyboardKeymap, IEntity, TickOrder, GgWorld, KeyboardInput } from '../../../../base';
-import { RaycastVehicle3dEntity } from '../../raycast-vehicle-3d.entity';
+import { Observable } from 'rxjs';
+import { DirectionKeyboardInput, DirectionKeyboardKeymap, GgWorld, IEntity, KeyboardInput, TickOrder } from '../../../../base';
 export declare type CarKeyboardControllerOptions = {
-    keymap: DirectionKeyboardKeymap;
-    gearUpDownKeys: [string, string];
-    handbrakeKey: string;
+    readonly keymap: DirectionKeyboardKeymap;
+    readonly maxSteerDeltaPerSecond: number;
+};
+export declare type CarHandlingOutput = {
+    upDown: number;
+    leftRight: number;
 };
 export declare class CarKeyboardHandlingController extends IEntity {
     protected readonly keyboard: KeyboardInput;
-    car: RaycastVehicle3dEntity | null;
     protected readonly options: CarKeyboardControllerOptions;
     readonly tickOrder = TickOrder.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: RaycastVehicle3dEntity | null, options?: CarKeyboardControllerOptions);
+    private _output$;
+    get output$(): Observable<CarHandlingOutput>;
+    constructor(keyboard: KeyboardInput, options?: CarKeyboardControllerOptions);
     onSpawned(world: GgWorld<any, any>): Promise<void>;
     onRemoved(): Promise<void>;
 }

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

@@ -7,97 +7,54 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { BehaviorSubject, combineLatest, filter, interval, pipe, takeUntil } from 'rxjs';
-import { distinctUntilChanged, map, pairwise, startWith, switchMap, take, tap } from 'rxjs/operators';
+import { combineLatest, Subject, takeUntil } from 'rxjs';
 import { DirectionKeyboardInput, IEntity, TickOrder, } from '../../../../base';
-// TODO pass as settings
-// TODO smooth y?
-const TICKER_INTERVAL = 16; // TODO when refactored, reflect in CarKeyboardHandlingController test
-const TICKER_MAX_STEPS = 10;
 export class CarKeyboardHandlingController extends IEntity {
-    constructor(keyboard, car, options = {
+    constructor(keyboard, options = {
         keymap: 'arrows',
-        gearUpDownKeys: ['KeyA', 'KeyZ'],
-        handbrakeKey: 'Space',
+        maxSteerDeltaPerSecond: 12,
     }) {
         super();
         this.keyboard = keyboard;
-        this.car = car;
         this.options = options;
         this.tickOrder = TickOrder.INPUT_CONTROLLERS;
-        // emits values -1 - 1; -1 = full turn left; 1 = full turn right
-        this.x$ = new BehaviorSubject(0);
-        // emits values -1 - 1; -1 = full brake; 1 = full acceleration
-        this.y$ = new BehaviorSubject(0);
-        this.lastX = 0;
-        this.switchingGearsEnabled = true;
-        this.pairTickerPipe = pipe(pairwise(), map(([beforeValue, afterValue]) => [this.lastX, afterValue]), switchMap(([beforeValue, afterValue]) => interval(TICKER_INTERVAL).pipe(startWith(-1), take(TICKER_MAX_STEPS), map(count => count + 2), map(count => beforeValue * ((TICKER_MAX_STEPS - count) / TICKER_MAX_STEPS) + afterValue * (count / TICKER_MAX_STEPS)), tap(x => {
-            this.lastX = x;
-        }))));
+        this._output$ = new Subject();
         this.directionsInput = new DirectionKeyboardInput(keyboard, options.keymap);
     }
+    get output$() {
+        return this._output$.asObservable();
+    }
     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(takeUntil(this._onRemoved$), 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(takeUntil(this._onRemoved$), 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.keyboard
-                .bind(this.options.handbrakeKey)
+            let input = { upDown: 0, leftRight: 0 };
+            combineLatest([this.directionsInput.output$, this.tick$])
                 .pipe(takeUntil(this._onRemoved$))
-                .subscribe(isKeyDown => {
-                if (this.car) {
-                    this.car.handBrake = isKeyDown;
+                .subscribe(([d, [_, dt]]) => {
+                const direction = { upDown: 0, leftRight: 0 };
+                if (d.leftRight !== undefined)
+                    direction.leftRight = d.leftRight ? 1 : -1;
+                if (d.upDown !== undefined)
+                    direction.upDown = d.upDown ? 1 : -1;
+                if (direction.leftRight != input.leftRight) {
+                    let diff = Math.abs(direction.leftRight - input.leftRight);
+                    let maxSteerInputDelta = (this.options.maxSteerDeltaPerSecond * dt) / 1000;
+                    if (diff > maxSteerInputDelta) {
+                        if (direction.leftRight < input.leftRight) {
+                            direction.leftRight = input.leftRight - maxSteerInputDelta;
+                        }
+                        else {
+                            direction.leftRight = input.leftRight + maxSteerInputDelta;
+                        }
+                    }
                 }
+                input = direction;
             });
-            this.directionsInput.output$.pipe(takeUntil(this._onRemoved$)).subscribe(d => {
-                moveDirection = d;
-            });
-            this.tick$
-                .pipe(takeUntil(this._onRemoved$), 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);
-            });
-            combineLatest([
-                this.x$.pipe(takeUntil(this._onRemoved$), distinctUntilChanged(), startWith(0), this.pairTickerPipe),
-                this.y$.pipe(takeUntil(this._onRemoved$), distinctUntilChanged(), startWith(0)),
-            ])
-                .pipe(takeUntil(this._onRemoved$))
-                .subscribe(([x, y]) => {
-                if (this.car) {
-                    this.car.setXAxisControlValue(x);
-                    this.car.setYAxisControlValue(y);
-                }
+            this.tick$.pipe(takeUntil(this._onRemoved$)).subscribe(() => {
+                this._output$.next(input);
             });
             yield this.directionsInput.start();
         });

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

@@ -0,0 +1,18 @@
+import { GgWorld, IEntity, KeyboardInput, TickOrder } from '../../../../base';
+import { GgCarEntity } from '../../gg-car/gg-car.entity';
+import { CarKeyboardControllerOptions, CarKeyboardHandlingController } from './car-keyboard-handling.controller';
+export declare type GgCarKeyboardControllerOptions = CarKeyboardControllerOptions & {
+    gearUpDownKeys: [string, string];
+    autoReverse: boolean;
+    handbrakeKey: string;
+};
+export declare class GgCarKeyboardHandlingController extends IEntity {
+    protected readonly keyboard: KeyboardInput;
+    car: GgCarEntity | null;
+    protected readonly options: GgCarKeyboardControllerOptions;
+    readonly tickOrder = TickOrder.INPUT_CONTROLLERS;
+    protected readonly carHandlingInput: CarKeyboardHandlingController;
+    switchingGearsEnabled: boolean;
+    constructor(keyboard: KeyboardInput, car: GgCarEntity | null, options?: GgCarKeyboardControllerOptions);
+    onSpawned(world: GgWorld<any, any>): Promise<void>;
+}

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

@@ -0,0 +1,96 @@
+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());
+    });
+};
+import { filter, takeUntil } from 'rxjs';
+import { IEntity, TickOrder } from '../../../../base';
+import { CarKeyboardHandlingController } from './car-keyboard-handling.controller';
+export class GgCarKeyboardHandlingController extends IEntity {
+    constructor(keyboard, car, options = {
+        keymap: 'arrows',
+        maxSteerDeltaPerSecond: 12,
+        gearUpDownKeys: ['KeyA', 'KeyZ'],
+        autoReverse: true,
+        handbrakeKey: 'Space',
+    }) {
+        super();
+        this.keyboard = keyboard;
+        this.car = car;
+        this.options = options;
+        this.tickOrder = TickOrder.INPUT_CONTROLLERS;
+        this.switchingGearsEnabled = true;
+        this.carHandlingInput = new CarKeyboardHandlingController(keyboard, options);
+        this.addChildren(this.carHandlingInput);
+    }
+    onSpawned(world) {
+        const _super = Object.create(null, {
+            onSpawned: { get: () => super.onSpawned }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.onSpawned.call(this, world);
+            this.carHandlingInput.output$.pipe(takeUntil(this._onRemoved$)).subscribe(({ upDown, leftRight }) => {
+                if (this.car) {
+                    this.car.steeringFactor = leftRight;
+                    if (upDown !== 0 && this.options.autoReverse && this.car.gear !== 0) {
+                        if (this.car.gear === -1) {
+                            if (upDown > 0 && this.car.raycastVehicle.getSpeed() > -1) {
+                                this.car.gear = 1;
+                            }
+                            else {
+                                upDown = -upDown;
+                            }
+                        }
+                        else {
+                            if (upDown < 0 && this.car.raycastVehicle.getSpeed() < 1) {
+                                this.car.gear = -1;
+                                upDown = -upDown;
+                            }
+                        }
+                    }
+                    if (upDown > 0) {
+                        this.car.acceleration = upDown;
+                        this.car.brake = 0;
+                    }
+                    else {
+                        this.car.acceleration = 0;
+                        this.car.brake = -upDown;
+                    }
+                }
+            });
+            this.keyboard
+                .bind(this.options.gearUpDownKeys[0])
+                .pipe(takeUntil(this._onRemoved$), 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(takeUntil(this._onRemoved$), 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.keyboard
+                .bind(this.options.handbrakeKey)
+                .pipe(takeUntil(this._onRemoved$))
+                .subscribe(isKeyDown => {
+                if (this.car) {
+                    this.car.handBrake = isKeyDown;
+                }
+            });
+        });
+    }
+}

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

@@ -0,0 +1,79 @@
+import { RaycastVehicle3dEntity, RVEntityProperties } from '../raycast-vehicle-3d.entity';
+import { IRenderableEntity, Point3, Point4 } from '../../../base';
+import { IPositionable3d } from '../../interfaces/i-positionable-3d';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Gg3dWorld } from '../../gg-3d-world';
+import { IDisplayObject3dComponent } from '../../components/rendering/i-display-object-3d.component';
+import { IRaycastVehicleComponent } from '../../components/physics/i-raycast-vehicle.component';
+export declare type GgCarProperties = RVEntityProperties & {
+    mpsToRpmFactor?: number;
+    engine: {
+        minRpm: number;
+        maxRpm: number;
+        torques: {
+            rpm: number;
+            torque: number;
+        }[];
+        maxRpmIncreasePerSecond: number;
+        maxRpmDecreasePerSecond: number;
+    };
+    brake: {
+        frontAxleForce: number;
+        rearAxleForce: number;
+        handbrakeForce: number;
+    };
+    transmission: {
+        isAuto: boolean;
+        reverseGearRatio: number;
+        gearRatios: number[];
+        drivelineEfficiency: number;
+        finalDriveRatio: number;
+        upShifts: number[];
+        autoHold: boolean;
+    };
+    maxSteerAngle: number;
+};
+export declare class GgCarEntity extends IRenderableEntity<Point3, Point4> implements IPositionable3d {
+    readonly carProperties: GgCarProperties;
+    readonly tickOrder: number;
+    get position(): Point3;
+    set position(value: Point3);
+    get rotation(): Point4;
+    set rotation(value: Point4);
+    protected get engineTorque(): number;
+    get transmissionGearRatio(): number;
+    protected get mpsToRpm(): number;
+    calculateRpmFromCarSpeed(): number;
+    protected readonly _rpm$: BehaviorSubject<number>;
+    get engineRpm$(): Observable<number>;
+    get engineRpm(): number;
+    protected get tractionForce(): number;
+    private _tailLightsOn;
+    get tailLightsOn(): boolean;
+    protected setTailLightsOn(value: boolean): void;
+    protected _acceleration$: BehaviorSubject<number>;
+    get acceleration(): number;
+    get acceleration$(): Observable<number>;
+    set acceleration(value: number);
+    protected _brake$: BehaviorSubject<number>;
+    get brake(): number;
+    set brake(value: number);
+    set steeringFactor(value: number);
+    protected handBrake$: BehaviorSubject<boolean>;
+    get handBrake(): boolean;
+    set handBrake(value: boolean);
+    private _gear;
+    private _gear$;
+    get gear(): number;
+    get gear$(): Observable<number>;
+    set gear(value: number);
+    set isHonking(value: boolean);
+    readonly raycastVehicle: RaycastVehicle3dEntity;
+    constructor(carProperties: GgCarProperties, chassis3D: IDisplayObject3dComponent | null, chassisBody: IRaycastVehicleComponent);
+    onSpawned(world: Gg3dWorld): void;
+    protected updateEngine(delta: number): void;
+    resetTo(options?: {
+        position?: Point3;
+        rotation?: Point4;
+    }): void;
+}

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

@@ -0,0 +1,228 @@
+import { RaycastVehicle3dEntity } from '../raycast-vehicle-3d.entity';
+import { cubicSplineInterpolation, IRenderableEntity, TickOrder } from '../../../base';
+import { BehaviorSubject, filter } from 'rxjs';
+import { throttleTime } from 'rxjs/operators';
+export class GgCarEntity extends IRenderableEntity {
+    constructor(carProperties, chassis3D, chassisBody) {
+        super();
+        this.carProperties = carProperties;
+        this.tickOrder = TickOrder.PHYSICS_SIMULATION - 5;
+        this._rpm$ = new BehaviorSubject(this.carProperties.engine.minRpm);
+        this._tailLightsOn = false;
+        // 0..1
+        this._acceleration$ = new BehaviorSubject(0);
+        // 0..1
+        this._brake$ = new BehaviorSubject(0);
+        this.handBrake$ = new BehaviorSubject(false);
+        this._gear = 0;
+        this._gear$ = new BehaviorSubject(0);
+        this.raycastVehicle = new RaycastVehicle3dEntity(carProperties, chassis3D, chassisBody);
+        this.addChildren(this.raycastVehicle);
+    }
+    get position() {
+        return this.raycastVehicle.position;
+    }
+    set position(value) {
+        this.raycastVehicle.position = value;
+    }
+    get rotation() {
+        return this.raycastVehicle.rotation;
+    }
+    set rotation(value) {
+        this.raycastVehicle.rotation = value;
+    }
+    get engineTorque() {
+        const currentRPM = this.engineRpm;
+        const torques = this.carProperties.engine.torques;
+        if (currentRPM <= torques[0].rpm) {
+            return torques[0].torque;
+        }
+        else if (currentRPM >= torques[torques.length - 1].rpm) {
+            return torques[torques.length - 1].torque;
+        }
+        let index = 0;
+        while (currentRPM > torques[index + 1].rpm) {
+            index++;
+        }
+        const x0 = torques[index].rpm;
+        const x1 = torques[index + 1].rpm;
+        const y0 = torques[index].torque;
+        const y1 = torques[index + 1].torque;
+        const m0 = index === 0 ? 0 : (y1 - torques[index - 1].torque) / (x1 - torques[index - 1].rpm);
+        const m1 = index === torques.length - 2 ? 0 : (torques[index + 2].torque - y0) / (torques[index + 2].rpm - x0);
+        return cubicSplineInterpolation(currentRPM, x0, x1, y0, y1, m0, m1);
+    }
+    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.raycastVehicle.tractionWheelRadius));
+    }
+    calculateRpmFromCarSpeed() {
+        return this.raycastVehicle.getSpeed() * this.mpsToRpm * this.transmissionGearRatio;
+    }
+    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.raycastVehicle.tractionWheelRadius);
+    }
+    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);
+        this.setTailLightsOn(value > 0.2);
+    }
+    // -1..1
+    set steeringFactor(value) {
+        this.raycastVehicle.steeringAngle = value * this.carProperties.maxSteerAngle;
+    }
+    get handBrake() {
+        return this.handBrake$.getValue();
+    }
+    set handBrake(value) {
+        this.handBrake$.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) { }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.tick$.subscribe(([_, delta]) => {
+            this.updateEngine(delta);
+            if (this.raycastVehicle.isTouchingGround) {
+                // TODO 1 - R (1000 rpm) quick switch with acceleration pedal should have the same speed as without acceleration pedal
+                let force = 0;
+                let brake = 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
+                    if (this.carProperties.transmission.autoHold) {
+                        const speedThreshold = 3;
+                        if (Math.abs(this.raycastVehicle.getSpeed()) < speedThreshold &&
+                            (this.gear == 0 || this.acceleration <= 0)) {
+                            brake = Math.max(brake, (0.3 * (speedThreshold - this.raycastVehicle.getSpeed())) / speedThreshold);
+                            force = 0;
+                        }
+                    }
+                }
+                this.raycastVehicle.applyTractionForce(force);
+                this.raycastVehicle.applyBrake('front', brake * this.carProperties.brake.frontAxleForce);
+                this.raycastVehicle.applyBrake('rear', brake * this.carProperties.brake.rearAxleForce);
+                if (this.handBrake) {
+                    this.raycastVehicle.applyBrake('rear', this.carProperties.brake.handbrakeForce);
+                }
+            }
+        });
+        if (this.carProperties.transmission.isAuto) {
+            this.tick$
+                .pipe(throttleTime(50), filter(() => this.raycastVehicle.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;
+                }
+            });
+        }
+    }
+    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.raycastVehicle.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.raycastVehicle.resetTo(options);
+        this.gear = 0;
+        this._rpm$.next(this.carProperties.engine.minRpm);
+    }
+}