@gg-web-engine/core 0.0.37 → 0.0.38

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

@@ -163,15 +163,17 @@ export class GgCarEntity extends IRenderable3dEntity {
                     }
                 }
                 if (brake === 0) {
-                    this.raycastVehicle.applyTractionForce(force);
+                    this.raycastVehicle.applyTraction('front', force * this.carProperties.tractionBias);
+                    this.raycastVehicle.applyTraction('rear', force * (1 - this.carProperties.tractionBias));
                     this.raycastVehicle.applyBrake('both', 0);
                 }
                 else {
-                    this.raycastVehicle.applyTractionForce(0);
+                    this.raycastVehicle.applyTraction('both', 0);
                     this.raycastVehicle.applyBrake('front', brake * this.carProperties.brake.frontAxleForce);
                     this.raycastVehicle.applyBrake('rear', brake * this.carProperties.brake.rearAxleForce);
                 }
                 if (this.handBrake) {
+                    this.raycastVehicle.applyTraction('rear', 0);
                     this.raycastVehicle.applyBrake('rear', this.carProperties.brake.handbrakeForce);
                 }
             }

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

@@ -40,7 +40,7 @@ export declare type Gg3dMapGraphEntityOptions = {
 export declare class MapGraph3dEntity<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRenderable3dEntity<VTypeDoc, PTypeDoc> {
     readonly mapGraph: MapGraph;
     readonly tickOrder = TickOrder.POST_RENDERING;
-    readonly loaderCursorEntity$: BehaviorSubject<IPositionable3d | null>;
+    readonly loaderCursorEntity$: BehaviorSubject<(IEntity & IPositionable3d) | null>;
     readonly loaded: Map<MapGraphNodeType, (IEntity & IPositionable3d)[]>;
     private _initialLoadComplete$;
     get initialLoadComplete$(): Observable<boolean>;

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

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { BehaviorSubject, NEVER, startWith, Subject, switchMap } from 'rxjs';
+import { BehaviorSubject, NEVER, startWith, Subject, switchMap, takeUntil } from 'rxjs';
 import { distinctUntilChanged, map, tap, throttleTime } from 'rxjs/operators';
 import { Graph, Qtrn, TickOrder } from '../../base';
 import { IRenderable3dEntity } from './i-renderable-3d.entity';
@@ -108,11 +108,10 @@ export class MapGraph3dEntity extends IRenderable3dEntity {
     }
     onSpawned(world) {
         super.onSpawned(world);
-        // TODO takeUntil removed from world?
         this.loaderCursorEntity$
-            .pipe(switchMap(entity => entity
+            .pipe(takeUntil(this._onRemoved$), switchMap(entity => entity
             ? this.tick$.pipe(startWith(null), // map will perform initial loading even if world not started yet. Handy to preload map
-            throttleTime(1000), map(() => entity.position))
+            takeUntil(entity.onRemoved$), throttleTime(1000), map(() => entity.position))
             : NEVER), map(pos => this.mapGraph.getNearestDummy(this.mapGraphNodes, pos)), tap(node => this._nearestDummy$.next(node)), distinctUntilChanged())
             .subscribe(currentChunk => {
             let haveToBeLoaded = new Set();

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

@@ -22,8 +22,12 @@ export declare type RVEntityAxleOptions = {
     axlePosition: number;
     axleHeight: number;
 } & RVEntitySharedWheelOptions;
+export declare enum RVEntityTractionBias {
+    FWD = 1,
+    RWD = 0
+}
 export declare type RVEntityProperties = {
-    typeOfDrive: 'RWD' | 'FWD' | '4WD';
+    tractionBias: RVEntityTractionBias | number;
     suspension: SuspensionOptions;
 } & ({
     wheelBase: {
@@ -42,21 +46,20 @@ export declare type RVEntityProperties = {
 export declare class RaycastVehicle3dEntity<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends Entity3d<VTypeDoc, PTypeDoc> {
     readonly carProperties: RVEntityProperties;
     readonly chassis3D: IDisplayObject3dComponent | null;
-    readonly chassisBody: IRaycastVehicleComponent;
+    readonly vehicleComponent: IRaycastVehicleComponent;
     protected readonly wheels: (Entity3d<VTypeDoc, PTypeDoc> | null)[];
     protected readonly wheelLocalRotation: (Point4 | null)[];
     protected readonly frontWheelsIndices: number[];
     protected readonly rearWheelsIndices: number[];
-    protected readonly tractionWheelIndices: number[];
     getSpeed(): number;
     readonly tractionWheelRadius: number;
     private _steeringAngle;
     get steeringAngle(): number;
     set steeringAngle(value: number);
-    applyTractionForce(force: number): void;
+    applyTraction(axle: 'front' | 'rear' | 'both', force: number): void;
     applyBrake(axle: 'front' | 'rear' | 'both', force: number): void;
     /** car mesh and physics body direction has to be pointing: y front, z up*/
-    constructor(carProperties: RVEntityProperties, chassis3D: IDisplayObject3dComponent | null, chassisBody: IRaycastVehicleComponent);
+    constructor(carProperties: RVEntityProperties, chassis3D: IDisplayObject3dComponent | null, vehicleComponent: IRaycastVehicleComponent);
     protected runTransformBinding(objectBody: IRigidBody3dComponent, object3D: IDisplayObject3dComponent): void;
     get isTouchingGround(): boolean;
     resetTo(options?: {

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

@@ -1,5 +1,10 @@
 import { Box, Pnt3, Qtrn } from '../../base';
 import { Entity3d } from './entity-3d';
+export var RVEntityTractionBias;
+(function (RVEntityTractionBias) {
+    RVEntityTractionBias[RVEntityTractionBias["FWD"] = 1] = "FWD";
+    RVEntityTractionBias[RVEntityTractionBias["RWD"] = 0] = "RWD";
+})(RVEntityTractionBias || (RVEntityTractionBias = {}));
 const wheeelDefaults = {
     tyreWidth: 0.3,
     tyreRadius: 0.4,
@@ -9,16 +14,15 @@ const wheeelDefaults = {
 };
 export class RaycastVehicle3dEntity extends Entity3d {
     /** car mesh and physics body direction has to be pointing: y front, z up*/
-    constructor(carProperties, chassis3D, chassisBody) {
-        super(chassis3D, chassisBody);
+    constructor(carProperties, chassis3D, vehicleComponent) {
+        super(chassis3D, vehicleComponent);
         this.carProperties = carProperties;
         this.chassis3D = chassis3D;
-        this.chassisBody = chassisBody;
+        this.vehicleComponent = vehicleComponent;
         this.wheels = [];
         this.wheelLocalRotation = [];
         this.frontWheelsIndices = [];
         this.rearWheelsIndices = [];
-        this.tractionWheelIndices = [];
         this._steeringAngle = 0;
         let wheelFullOptions = 'wheelBase' in carProperties
             ? [
@@ -47,15 +51,11 @@ export class RaycastVehicle3dEntity extends Entity3d {
             else {
                 this.rearWheelsIndices.push(i);
             }
-            if (wheelOpts.isFront && this.carProperties.typeOfDrive != 'RWD') {
-                this.tractionWheelIndices.push(i);
-            }
-            if (!wheelOpts.isFront && this.carProperties.typeOfDrive != 'FWD') {
-                this.tractionWheelIndices.push(i);
-            }
-            this.chassisBody.addWheel(wheelOpts, this.carProperties.suspension);
+            this.vehicleComponent.addWheel(wheelOpts, this.carProperties.suspension);
         });
-        this.tractionWheelRadius = wheelFullOptions[this.tractionWheelIndices[0]].tyreRadius;
+        this.tractionWheelRadius =
+            wheelFullOptions[this.frontWheelsIndices[0]].tyreRadius * this.carProperties.tractionBias +
+                wheelFullOptions[this.rearWheelsIndices[0]].tyreRadius * (1 - this.carProperties.tractionBias);
         for (const options of wheelFullOptions) {
             const display = options.display || {};
             if (!display.displayObject) {
@@ -96,11 +96,11 @@ export class RaycastVehicle3dEntity extends Entity3d {
             this.wheels.push(new Entity3d(entity));
         }
         this.addChildren(...this.wheels.filter(x => !!x));
-        this.chassisBody.entity = this;
+        this.vehicleComponent.entity = this;
     }
     // m/s
     getSpeed() {
-        return this.chassisBody.wheelSpeed;
+        return this.vehicleComponent.wheelSpeed;
     }
     get steeringAngle() {
         return this._steeringAngle;
@@ -109,17 +109,22 @@ export class RaycastVehicle3dEntity extends Entity3d {
         if (this._steeringAngle != value) {
             this._steeringAngle = value;
         }
-        this.frontWheelsIndices.forEach(index => this.chassisBody.setSteering(index, value));
+        this.frontWheelsIndices.forEach(index => this.vehicleComponent.setSteering(index, value));
     }
-    applyTractionForce(force) {
-        this.tractionWheelIndices.forEach(index => this.chassisBody.applyEngineForce(index, force));
+    applyTraction(axle, force) {
+        if (axle != 'rear') {
+            this.frontWheelsIndices.forEach(index => this.vehicleComponent.applyEngineForce(index, force));
+        }
+        if (axle != 'front') {
+            this.rearWheelsIndices.forEach(index => this.vehicleComponent.applyEngineForce(index, force));
+        }
     }
     applyBrake(axle, force) {
         if (axle != 'rear') {
-            this.frontWheelsIndices.forEach(index => this.chassisBody.applyBrake(index, force));
+            this.frontWheelsIndices.forEach(index => this.vehicleComponent.applyBrake(index, force));
         }
         if (axle != 'front') {
-            this.rearWheelsIndices.forEach(index => this.chassisBody.applyBrake(index, force));
+            this.rearWheelsIndices.forEach(index => this.vehicleComponent.applyBrake(index, force));
         }
     }
     runTransformBinding(objectBody, object3D) {
@@ -128,7 +133,7 @@ export class RaycastVehicle3dEntity extends Entity3d {
             if (!wheel) {
                 continue;
             }
-            let { position, rotation } = this.chassisBody.getWheelTransform(i);
+            let { position, rotation } = this.vehicleComponent.getWheelTransform(i);
             if (this.wheelLocalRotation[i]) {
                 rotation = Qtrn.combineRotations(rotation, this.wheelLocalRotation[i]);
             }
@@ -138,14 +143,24 @@ export class RaycastVehicle3dEntity extends Entity3d {
     }
     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);
+        if (this.carProperties.tractionBias != RVEntityTractionBias.RWD) {
+            if (this.frontWheelsIndices
+                .map(i => this.vehicleComponent.isWheelTouchesGround(i))
+                .reduce((prev, cur) => cur || prev, false)) {
+                return true;
+            }
+        }
+        if (this.carProperties.tractionBias != RVEntityTractionBias.FWD) {
+            if (this.rearWheelsIndices
+                .map(i => this.vehicleComponent.isWheelTouchesGround(i))
+                .reduce((prev, cur) => cur || prev, false)) {
+                return true;
+            }
+        }
+        return false;
     }
     // 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;
         }
@@ -153,5 +168,6 @@ export class RaycastVehicle3dEntity extends Entity3d {
             this.rotation = options.rotation;
         }
         this.steeringAngle = 0;
+        this.vehicleComponent.resetMotion();
     }
 }

package/dist/base/entities/i-entity.d.ts

@@ -1,5 +1,5 @@
 import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../gg-world';
-import { Subject } from 'rxjs';
+import { Observable, Subject } from 'rxjs';
 import { IWorldComponent } from '../components/i-world-component';
 /**
  * Engine's default tick orders: the less value, the earlier tick will be run.
@@ -48,6 +48,8 @@ export declare abstract class IEntity<D = any, R = any, VTypeDoc extends VisualT
     removeComponents(components: IWorldComponent<D, R, VTypeDoc, PTypeDoc>[], dispose?: boolean): void;
     protected _onSpawned$: Subject<void>;
     protected _onRemoved$: Subject<void>;
+    get onSpawned$(): Observable<void>;
+    get onRemoved$(): Observable<void>;
     onSpawned(world: GgWorld<D, R, VTypeDoc, PTypeDoc>): void;
     onRemoved(): void;
     dispose(): void;

package/dist/base/entities/i-entity.js

@@ -100,6 +100,12 @@ export class IEntity {
             }
         }
     }
+    get onSpawned$() {
+        return this._onSpawned$.asObservable();
+    }
+    get onRemoved$() {
+        return this._onRemoved$.asObservable();
+    }
     onSpawned(world) {
         this._world = world;
         for (const c of this._components) {

package/dist/base/math/point2.d.ts

@@ -12,12 +12,20 @@ export declare class Pnt2 {
     static get nY(): Point2;
     /** clone point */
     static clone(p: Point2): Point2;
+    /** spread point components */
+    static spr(p: Point2): [number, number];
+    /** get negation of the point */
+    static neg(p: Point2): Point2;
     /** add point b to point a */
     static add(a: Point2, b: Point2): Point2;
     /** subtract point b from point a */
     static sub(a: Point2, b: Point2): Point2;
+    /** scale point b by point. The result is the point, where each component is a product of appropriate components of input points */
+    static scale(a: Point2, s: Point2): Point2;
     /** average point between a and b */
     static avg(a: Point2, b: Point2): Point2;
+    /** round point components */
+    static round(p: Point2): Point2;
     /** calculate vector length (squared) */
     static lenSq(v: Point2): number;
     /** calculate vector length */
@@ -32,4 +40,8 @@ export declare class Pnt2 {
     static lerp(a: Point2, b: Point2, t: number): Point2;
     /** angle between vectors in radians */
     static angle(a: Point2, b: Point2): number;
+    /** rotate point around zero by provided angle */
+    static rot(p: Point2, angle: number): Point2;
+    /** rotate point around pivot by provided angle */
+    static rotAround(p: Point2, pivot: Point2, angle: number): Point2;
 }

package/dist/base/math/point2.js

@@ -23,6 +23,14 @@ export class Pnt2 {
     static clone(p) {
         return { x: p.x, y: p.y };
     }
+    /** spread point components */
+    static spr(p) {
+        return [p.x, p.y];
+    }
+    /** get negation of the point */
+    static neg(p) {
+        return { x: -p.x, y: -p.y };
+    }
     /** add point b to point a */
     static add(a, b) {
         return { x: a.x + b.x, y: a.y + b.y };
@@ -31,10 +39,18 @@ export class Pnt2 {
     static sub(a, b) {
         return { x: a.x - b.x, y: a.y - b.y };
     }
+    /** scale point b by point. The result is the point, where each component is a product of appropriate components of input points */
+    static scale(a, s) {
+        return { x: a.x * s.x, y: a.y * s.y };
+    }
     /** average point between a and b */
     static avg(a, b) {
         return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
     }
+    /** round point components */
+    static round(p) {
+        return { x: Math.round(p.x), y: Math.round(p.y) };
+    }
     /** calculate vector length (squared) */
     static lenSq(v) {
         return v.x * v.x + v.y * v.y;
@@ -75,4 +91,23 @@ export class Pnt2 {
         const magnitudeProduct = Math.sqrt(a.x ** 2 + a.y ** 2) * Math.sqrt(b.x ** 2 + b.y ** 2);
         return Math.acos(dotProduct / magnitudeProduct);
     }
+    /** rotate point around zero by provided angle */
+    static rot(p, angle) {
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        return {
+            x: p.x * cos - p.y * sin,
+            y: p.x * sin + p.y * cos,
+        };
+    }
+    /** rotate point around pivot by provided angle */
+    static rotAround(p, pivot, angle) {
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        const p0 = { x: p.x - pivot.x, y: p.y - pivot.y };
+        return {
+            x: p0.x * cos - p0.y * sin + pivot.x,
+            y: p0.x * sin + p0.y * cos + pivot.y,
+        };
+    }
 }

package/dist/base/math/point3.d.ts

@@ -16,12 +16,20 @@ export declare class Pnt3 {
     static get nZ(): Point3;
     /** clone point */
     static clone(p: Point3): Point3;
+    /** spread point components */
+    static spr(p: Point3): [number, number, number];
+    /** get negation of the point */
+    static neg(p: Point3): Point3;
     /** add point b to point a */
     static add(a: Point3, b: Point3): Point3;
     /** subtract point b from point a */
     static sub(a: Point3, b: Point3): Point3;
+    /** scale point b by point. The result is the point, where each component is a product of appropriate components of input points */
+    static scale(a: Point3, s: Point3): Point3;
     /** average point between a and b */
     static avg(a: Point3, b: Point3): Point3;
+    /** round point components */
+    static round(p: Point3): Point3;
     /** calculate vector length (squared) */
     static lenSq(v: Point3): number;
     /** calculate vector length */

package/dist/base/math/point3.js

@@ -32,6 +32,14 @@ export class Pnt3 {
     static clone(p) {
         return { x: p.x, y: p.y, z: p.z };
     }
+    /** spread point components */
+    static spr(p) {
+        return [p.x, p.y, p.z];
+    }
+    /** get negation of the point */
+    static neg(p) {
+        return { x: -p.x, y: -p.y, z: -p.z };
+    }
     /** add point b to point a */
     static add(a, b) {
         return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
@@ -40,10 +48,18 @@ export class Pnt3 {
     static sub(a, b) {
         return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
     }
+    /** scale point b by point. The result is the point, where each component is a product of appropriate components of input points */
+    static scale(a, s) {
+        return { x: a.x * s.x, y: a.y * s.y, z: a.z * s.z };
+    }
     /** average point between a and b */
     static avg(a, b) {
         return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2, z: (a.z + b.z) / 2 };
     }
+    /** round point components */
+    static round(p) {
+        return { x: Math.round(p.x), y: Math.round(p.y), z: Math.round(p.z) };
+    }
     /** calculate vector length (squared) */
     static lenSq(v) {
         return v.x * v.x + v.y * v.y + v.z * v.z;

package/dist/base/math/quaternion.d.ts

@@ -18,6 +18,8 @@ export declare class Qtrn {
      * @returns A new Point4 instance with the same values as the given Point4 object.
      */
     static clone(q: Point4): Point4;
+    /** spread quaternion components */
+    static spr(p: Point4): [number, number, number, number];
     /**
      * Returns the sum of two Point4 objects.
      * @param a The first Point4 object to add.

package/dist/base/math/quaternion.js

@@ -23,6 +23,10 @@ export class Qtrn {
     static clone(q) {
         return { x: q.x, y: q.y, z: q.z, w: q.w };
     }
+    /** spread quaternion components */
+    static spr(p) {
+        return [p.x, p.y, p.z, p.w];
+    }
     /**
      * Returns the sum of two Point4 objects.
      * @param a The first Point4 object to add.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/core",
-  "version": "0.0.37",
+  "version": "0.0.38",
   "description": "An attempt to create open source game engine for browser",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,11 +27,11 @@
   },
   "homepage": "https://github.com/AndyGura/gg-web-engine#readme",
   "dependencies": {
-    "rxjs": "7.8.0",
+    "rxjs": "7.8.1",
     "stats.js": "0.17.0"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.0",
+    "@types/jest": "^29.5.12",
     "@types/stats.js": "^0.17.0",
     "jest": "^29.5.0",
     "jest-environment-jsdom": "^29.5.0",