@gg-web-engine/core 0.0.38 → 0.0.40

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

@@ -1,5 +1,8 @@
 import { IRigidBodyComponent, Point2 } from '../../../base';
 import { PhysicsTypeDocRepo2D } from '../../gg-2d-world';
+import { DebugBody2DSettings } from '../../models/body-options';
 export interface IRigidBody2dComponent<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IRigidBodyComponent<Point2, number, TypeDoc> {
     angularVelocity: number;
+    /** body info for physics debugger view */
+    readonly debugBodySettings: DebugBody2DSettings;
 }

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

@@ -1,7 +1,10 @@
 import { ITriggerComponent, Point2 } from '../../../base';
 import { Observable } from 'rxjs';
 import { PhysicsTypeDocRepo2D } from '../../gg-2d-world';
+import { DebugBody2DSettings } from '../../models/body-options';
 export interface ITrigger2dComponent<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends ITriggerComponent<Point2, number, TypeDoc> {
+    /** body info for physics debugger view */
+    readonly debugBodySettings: DebugBody2DSettings;
     get onEntityEntered(): Observable<TypeDoc['rigidBody']>;
     get onEntityLeft(): Observable<TypeDoc['rigidBody'] | null>;
 }

package/dist/2d/components/rendering/i-visual-scene-2d.component.d.ts

@@ -1,5 +1,5 @@
 import { IVisualSceneComponent, Point2, RendererOptions } from '../../../base';
 import { VisualTypeDocRepo2D } from '../../gg-2d-world';
 export interface IVisualScene2dComponent<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IVisualSceneComponent<Point2, number, TypeDoc> {
-    createRenderer(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions>): TypeDoc['renderer'];
+    createRenderer(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & TypeDoc['rendererExtraOpts']>): TypeDoc['renderer'];
 }

package/dist/2d/entities/i-renderable-2d.entity.d.ts

@@ -1,4 +1,6 @@
 import { IRenderableEntity, Point2 } from '../../base';
-import { PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from '../gg-2d-world';
+import { Gg2dWorld, PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from '../gg-2d-world';
 export declare abstract class IRenderable2dEntity<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D, PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IRenderableEntity<Point2, number, TypeDoc, PTypeDoc> {
+    protected _world: Gg2dWorld<TypeDoc, PTypeDoc> | null;
+    get world(): Gg2dWorld<TypeDoc, PTypeDoc> | null;
 }

package/dist/2d/entities/i-renderable-2d.entity.js

@@ -1,3 +1,10 @@
 import { IRenderableEntity } from '../../base';
 export class IRenderable2dEntity extends IRenderableEntity {
+    constructor() {
+        super(...arguments);
+        this._world = null;
+    }
+    get world() {
+        return this._world;
+    }
 }

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

@@ -13,6 +13,7 @@ export declare type VisualTypeDocRepo2D = {
     factory: IDisplayObject2dComponentFactory;
     displayObject: IDisplayObject2dComponent;
     renderer: IRenderer2dComponent;
+    rendererExtraOpts: {};
     texture: unknown;
 };
 export declare type PhysicsTypeDocRepo2D = {

package/dist/2d/models/body-options.d.ts

@@ -1,3 +1,7 @@
-import { BodyOptions } from '../../base';
+import { BodyOptions, DebugBodySettings } from '../../base';
+import { Shape2DDescriptor } from './shapes';
 export interface Body2DOptions extends BodyOptions {
 }
+export declare type DebugBody2DSettings = DebugBodySettings & {
+    shape: Shape2DDescriptor;
+};

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

@@ -1,5 +1,12 @@
 import { IPhysicsWorldComponent, Point3, Point4 } from '../../../base';
 import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
+import { Subject } from 'rxjs';
 export interface IPhysicsWorld3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IPhysicsWorldComponent<Point3, Point4, TypeDoc> {
     readonly loader: TypeDoc['loader'];
+    /** event emitter, emits newly added physics components */
+    readonly added$: Subject<TypeDoc['trigger'] | TypeDoc['rigidBody'] | TypeDoc['raycastVehicle'] | any>;
+    /** event emitter, emits just removed physics components */
+    readonly removed$: Subject<TypeDoc['trigger'] | TypeDoc['rigidBody'] | TypeDoc['raycastVehicle'] | any>;
+    /** list of currently added to world physics components */
+    readonly children: (TypeDoc['trigger'] | TypeDoc['rigidBody'] | TypeDoc['raycastVehicle'] | any)[];
 }

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

@@ -1,5 +1,8 @@
 import { IRigidBodyComponent, Point3, Point4 } from '../../../base';
 import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
+import { DebugBody3DSettings } from '../../models/body-options';
 export interface IRigidBody3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRigidBodyComponent<Point3, Point4, TypeDoc> {
     angularVelocity: Point3;
+    /** body info for physics debugger view */
+    readonly debugBodySettings: DebugBody3DSettings;
 }

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

@@ -1,7 +1,10 @@
 import { ITriggerComponent, Point3, Point4 } from '../../../base';
 import { Observable } from 'rxjs';
 import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
+import { DebugBody3DSettings } from '../../models/body-options';
 export interface ITrigger3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends ITriggerComponent<Point3, Point4, TypeDoc> {
+    /** body info for physics debugger view */
+    readonly debugBodySettings: DebugBody3DSettings;
     get onEntityEntered(): Observable<TypeDoc['rigidBody']>;
     get onEntityLeft(): Observable<TypeDoc['rigidBody'] | null>;
 }

package/dist/3d/components/rendering/i-visual-scene-3d.component.d.ts

@@ -2,5 +2,5 @@ import { IVisualSceneComponent, Point3, Point4, RendererOptions } from '../../..
 import { VisualTypeDocRepo3D } from '../../gg-3d-world';
 export interface IVisualScene3dComponent<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IVisualSceneComponent<Point3, Point4, TypeDoc> {
     readonly loader: TypeDoc['loader'];
-    createRenderer(camera: TypeDoc['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions>): TypeDoc['renderer'];
+    createRenderer(camera: TypeDoc['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & TypeDoc['rendererExtraOpts']>): TypeDoc['renderer'];
 }

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

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { combineLatest, Subject, takeUntil } from 'rxjs';
+import { combineLatest, filter, Subject, takeUntil } from 'rxjs';
 import { DirectionKeyboardInput, IEntity, TickOrder, } from '../../../../base';
 export class CarKeyboardHandlingController extends IEntity {
     constructor(keyboard, options = {
@@ -32,7 +32,7 @@ export class CarKeyboardHandlingController extends IEntity {
             _super.onSpawned.call(this, world);
             let input = { upDown: 0, leftRight: 0 };
             combineLatest([this.directionsInput.output$, this.tick$])
-                .pipe(takeUntil(this._onRemoved$))
+                .pipe(filter(() => this.active), takeUntil(this._onRemoved$))
                 .subscribe(([d, [_, dt]]) => {
                 const direction = { upDown: 0, leftRight: 0 };
                 if (d.leftRight !== undefined)

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

@@ -64,7 +64,7 @@ export class GgCarKeyboardHandlingController extends IEntity {
             });
             this.keyboard
                 .bind(this.options.gearUpDownKeys[0])
-                .pipe(takeUntil(this._onRemoved$), filter(x => this.switchingGearsEnabled && !!x))
+                .pipe(takeUntil(this._onRemoved$), filter(x => this.active && this.switchingGearsEnabled && !!x))
                 .subscribe(() => {
                 if (this.car && (!this.car.carProperties.transmission.isAuto || this.car.gear <= 0)) {
                     this.car.gear++;
@@ -72,7 +72,7 @@ export class GgCarKeyboardHandlingController extends IEntity {
             });
             this.keyboard
                 .bind(this.options.gearUpDownKeys[1])
-                .pipe(takeUntil(this._onRemoved$), filter(x => this.switchingGearsEnabled && !!x))
+                .pipe(takeUntil(this._onRemoved$), filter(x => this.active && this.switchingGearsEnabled && !!x))
                 .subscribe(() => {
                 if (this.car) {
                     if (this.car.carProperties.transmission.isAuto && this.car.gear > 1) {
@@ -85,7 +85,7 @@ export class GgCarKeyboardHandlingController extends IEntity {
             });
             this.keyboard
                 .bind(this.options.handbrakeKey)
-                .pipe(takeUntil(this._onRemoved$))
+                .pipe(takeUntil(this._onRemoved$), filter(() => this.active))
                 .subscribe(isKeyDown => {
                 if (this.car) {
                     this.car.handBrake = isKeyDown;

package/dist/3d/entities/i-renderable-3d.entity.d.ts

@@ -1,4 +1,6 @@
 import { IRenderableEntity, Point3, Point4 } from '../../base';
-import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
+import { Gg3dWorld, PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
 export declare abstract class IRenderable3dEntity<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRenderableEntity<Point3, Point4, TypeDoc, PTypeDoc> {
+    protected _world: Gg3dWorld<TypeDoc, PTypeDoc> | null;
+    get world(): Gg3dWorld<TypeDoc, PTypeDoc> | null;
 }

package/dist/3d/entities/i-renderable-3d.entity.js

@@ -1,3 +1,10 @@
 import { IRenderableEntity } from '../../base';
 export class IRenderable3dEntity extends IRenderableEntity {
+    constructor() {
+        super(...arguments);
+        this._world = null;
+    }
+    get world() {
+        return this._world;
+    }
 }

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

@@ -1,5 +1,5 @@
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
-import { Graph, IEntity, Point3, Point4, TickOrder } from '../../base';
+import { Graph, IEntity, PausableClock, Point3, Point4, TickOrder } from '../../base';
 import { Gg3dWorld, PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
 import { Entity3d } from './entity-3d';
 import { LoadOptions, LoadResultWithProps } from '../loader';
@@ -60,10 +60,9 @@ export declare class MapGraph3dEntity<VTypeDoc extends VisualTypeDocRepo3D = Vis
             rotation: Point4;
         }
     ]>;
-    get world(): Gg3dWorld<VTypeDoc, PTypeDoc> | null;
-    protected _world: Gg3dWorld<VTypeDoc, PTypeDoc> | null;
     protected readonly mapGraphNodes: MapGraph[];
     protected readonly options: Gg3dMapGraphEntityOptions;
+    protected loadClock: PausableClock | null;
     constructor(mapGraph: MapGraph, options?: Partial<Gg3dMapGraphEntityOptions>);
     onSpawned(world: Gg3dWorld<VTypeDoc, PTypeDoc>): void;
     onRemoved(): void;

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

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { BehaviorSubject, NEVER, startWith, Subject, switchMap, takeUntil } from 'rxjs';
-import { distinctUntilChanged, map, tap, throttleTime } from 'rxjs/operators';
+import { distinctUntilChanged, map, tap } from 'rxjs/operators';
 import { Graph, Qtrn, TickOrder } from '../../base';
 import { IRenderable3dEntity } from './i-renderable-3d.entity';
 export class MapGraph extends Graph {
@@ -90,7 +90,7 @@ export class MapGraph3dEntity extends IRenderable3dEntity {
         this._initialLoadComplete$ = new BehaviorSubject(false);
         this._nearestDummy$ = new BehaviorSubject(null);
         this._chunkLoaded$ = new Subject();
-        this._world = null;
+        this.loadClock = null;
         this.options = Object.assign(Object.assign({}, defaultOptions), options);
         this.mapGraphNodes = mapGraph.nodes();
     }
@@ -103,15 +103,14 @@ export class MapGraph3dEntity extends IRenderable3dEntity {
     get chunkLoaded$() {
         return this._chunkLoaded$.asObservable();
     }
-    get world() {
-        return this._world;
-    }
     onSpawned(world) {
         super.onSpawned(world);
+        this.loadClock = world.createClock(true);
+        this.loadClock.tickRateLimit = 1;
         this.loaderCursorEntity$
             .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
-            takeUntil(entity.onRemoved$), throttleTime(1000), map(() => entity.position))
+            ? this.loadClock.tick$.pipe(startWith(null), // map will perform initial loading even if world not started yet. Handy to preload map
+            takeUntil(entity.onRemoved$), 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();
@@ -143,6 +142,10 @@ export class MapGraph3dEntity extends IRenderable3dEntity {
     }
     onRemoved() {
         super.onRemoved();
+        if (this.loadClock) {
+            this.loadClock.stop();
+            this.loadClock = null;
+        }
         this.loaderCursorEntity$.next(null);
     }
     loadChunk(node) {

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

@@ -51,6 +51,8 @@ export declare class RaycastVehicle3dEntity<VTypeDoc extends VisualTypeDocRepo3D
     protected readonly wheelLocalRotation: (Point4 | null)[];
     protected readonly frontWheelsIndices: number[];
     protected readonly rearWheelsIndices: number[];
+    get name(): string;
+    set name(value: string);
     getSpeed(): number;
     readonly tractionWheelRadius: number;
     private _steeringAngle;

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

@@ -93,11 +93,25 @@ export class RaycastVehicle3dEntity extends Entity3d {
                 localRotation = { x: 0, y: 0.707107 * (flip ? 1 : -1), z: 0, w: 0.707107 };
             }
             this.wheelLocalRotation.push(localRotation);
-            this.wheels.push(new Entity3d(entity));
+            const wheelEntity = new Entity3d(entity);
+            wheelEntity.name = this.name + '__wheel_' + (options.isFront ? 'f' : 'r') + (options.isLeft ? 'l' : 'r');
+            this.wheels.push(wheelEntity);
         }
         this.addChildren(...this.wheels.filter(x => !!x));
         this.vehicleComponent.entity = this;
     }
+    get name() {
+        return super.name;
+    }
+    set name(value) {
+        const oldName = super.name;
+        super.name = value;
+        for (const w of this.wheels || []) {
+            if (w) {
+                w.name = w.name.replace(oldName, value);
+            }
+        }
+    }
     // m/s
     getSpeed() {
         return this.vehicleComponent.wheelSpeed;

package/dist/3d/factories.d.ts

@@ -1,15 +1,15 @@
-import { BodyShape3DDescriptor, Shape3DDescriptor } from './models/shapes';
+import { BodyShape3DDescriptor, Shape3DDescriptor, Shape3DMeshDescriptor } from './models/shapes';
 import { Point3, Point4 } from '../base';
 import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from './gg-3d-world';
 export declare type DisplayObject3dOpts<Tex> = {
     color?: number;
-    shading?: 'unlit' | 'standart' | 'phong';
+    shading?: 'unlit' | 'standart' | 'phong' | 'wireframe';
     diffuse?: Tex;
     castShadow?: boolean;
     receiveShadow?: boolean;
 };
 export declare abstract class IDisplayObject3dComponentFactory<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> {
-    abstract createPrimitive(descriptor: Shape3DDescriptor, material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
+    abstract createPrimitive(descriptor: Shape3DMeshDescriptor, material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
     abstract createPerspectiveCamera(settings: {
         fov?: number;
         aspectRatio?: number;

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

@@ -18,6 +18,7 @@ export declare type VisualTypeDocRepo3D = {
     loader: IDisplayObject3dComponentLoader;
     displayObject: IDisplayObject3dComponent;
     renderer: IRenderer3dComponent;
+    rendererExtraOpts: {};
     camera: ICameraComponent;
     texture: unknown;
 };

package/dist/3d/models/body-options.d.ts

@@ -1,3 +1,7 @@
-import { BodyOptions } from '../../base';
+import { BodyOptions, DebugBodySettings } from '../../base';
+import { Shape3DDescriptor } from './shapes';
 export interface Body3DOptions extends BodyOptions {
 }
+export declare type DebugBody3DSettings = DebugBodySettings & {
+    shape: Shape3DDescriptor;
+};

package/dist/3d/models/shapes.d.ts

@@ -1,4 +1,4 @@
-import { Point3, Point4 } from '../../base';
+import { Point2, Point3, Point4 } from '../../base';
 import { Body3DOptions } from './body-options';
 export declare type Shape3DDescriptor = {
     shape: 'PLANE';
@@ -31,6 +31,46 @@ export declare type Shape3DDescriptor = {
     vertices: Point3[];
     faces: [number, number, number][];
 };
+export declare type Shape3DMeshDescriptor = {
+    shape: 'PLANE';
+    dimensions?: Point2;
+    segments?: Point2;
+} | {
+    shape: 'BOX';
+    dimensions: Point3;
+    segments?: Point3;
+} | {
+    shape: 'CONE' | 'CYLINDER';
+    radius: number;
+    height: number;
+    radialSegments?: number;
+    heightSegments?: number;
+} | {
+    shape: 'CAPSULE';
+    radius: number;
+    centersDistance: number;
+    capSegments?: number;
+    radialSegments?: number;
+} | {
+    shape: 'SPHERE';
+    radius: number;
+    widthSegments?: number;
+    heightSegments?: number;
+} | {
+    shape: 'COMPOUND';
+    children: {
+        position?: Point3;
+        rotation?: Point4;
+        shape: Shape3DMeshDescriptor;
+    }[];
+} | {
+    shape: 'CONVEX_HULL';
+    vertices: Point3[];
+} | {
+    shape: 'MESH';
+    vertices: Point3[];
+    faces: [number, number, number][];
+};
 export declare type BodyShape3DDescriptor = {
     shape: Shape3DDescriptor;
     body: Partial<Body3DOptions>;

package/dist/base/clock/pausable-clock.d.ts

@@ -1,25 +1,86 @@
 import { Observable } from 'rxjs';
 import { IClock } from './i-clock';
 /**
- * A class, providing ability to track time, fire ticks, provide time elapsed + tick delta with ability to suspend/resume it.
+ * A class providing the ability to track time, fire ticks, provide time elapsed, and tick delta with the ability to suspend/resume it.
  */
 export declare class PausableClock implements IClock {
     protected readonly parentClock: IClock;
     private tickSub;
+    private readonly _internalTick$;
     private readonly _tick$;
+    /**
+     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
+     */
     get tick$(): Observable<[number, number]>;
+    /**
+     * Checks if the clock is currently running.
+     */
     get isRunning(): boolean;
+    /**
+     * Checks if the clock is currently paused.
+     */
     get isPaused(): boolean;
+    /**
+     * Checks if the clock is stopped.
+     */
+    get isStopped(): boolean;
+    /**
+     * Gets the time scale of the clock.
+     */
+    get timeScale(): number;
+    /**
+     * Sets the time scale of the clock.
+     */
+    set timeScale(value: number);
+    /**
+     * Gets the elapsed time since the clock started.
+     */
     get elapsedTime(): number;
+    /**
+     * Tick rate limiter. If set to 0 - tick rate is unlimited, 15 means "allow at most 15 ticks per second"
+     */
+    tickRateLimit: number;
     private startedAt;
     private oldRelativeTime;
     private pausedAt;
+    private lastStopElapsed;
+    private _timeScale;
+    private pausedByTimescale;
+    private lastFiredTickElapsed;
+    /**
+     * Constructs a new PausableClock instance.
+     * @param autoStart Indicates whether the clock should start automatically upon creation.
+     * @param parentClock The parent clock to synchronize with. Defaults to GgGlobalClock instance.
+     */
     constructor(autoStart?: boolean, parentClock?: IClock);
+    /**
+     * Creates a child clock.
+     * @param autoStart Indicates whether the child clock should start automatically.
+     * @returns A new instance of PausableClock.
+     */
     createChildClock(autoStart: boolean): PausableClock;
+    /**
+     * Starts the clock.
+     */
     start(): void;
+    /**
+     * Stops the clock.
+     */
     stop(): void;
+    /**
+     * Pauses the clock.
+     */
     pause(): void;
+    /**
+     * Resumes the clock.
+     */
     resume(): void;
+    /**
+     * Starts listening for ticks from the parent clock.
+     */
     protected startListeningTicks(): void;
+    /**
+     * Stops listening for ticks from the parent clock.
+     */
     protected stopListeningTicks(): void;
 }

package/dist/base/clock/pausable-clock.js

@@ -1,40 +1,117 @@
-import { Subject } from 'rxjs';
+import { filter, Subject } from 'rxjs';
 import { map, tap } from 'rxjs/operators';
 import { GgGlobalClock } from './global-clock';
 /**
- * A class, providing ability to track time, fire ticks, provide time elapsed + tick delta with ability to suspend/resume it.
+ * A class providing the ability to track time, fire ticks, provide time elapsed, and tick delta with the ability to suspend/resume it.
  */
 export class PausableClock {
+    /**
+     * Constructs a new PausableClock instance.
+     * @param autoStart Indicates whether the clock should start automatically upon creation.
+     * @param parentClock The parent clock to synchronize with. Defaults to GgGlobalClock instance.
+     */
     constructor(autoStart = false, parentClock = GgGlobalClock.instance) {
         this.parentClock = parentClock;
         this.tickSub = null;
+        this._internalTick$ = new Subject();
         this._tick$ = new Subject();
-        // state
+        /**
+         * Tick rate limiter. If set to 0 - tick rate is unlimited, 15 means "allow at most 15 ticks per second"
+         */
+        this.tickRateLimit = 0;
+        // State variables
         this.startedAt = -1;
         this.oldRelativeTime = 0; // "elapsed", emitted on last tick
         this.pausedAt = -1;
+        this.lastStopElapsed = 0;
+        this._timeScale = 1;
+        this.pausedByTimescale = false;
+        this.lastFiredTickElapsed = 0;
         if (autoStart) {
             this.start();
         }
+        this._internalTick$
+            .pipe(map(([_, newTime]) => [newTime, newTime - this.lastFiredTickElapsed]), filter(([elapsed]) => !this.tickRateLimit ||
+            Math.floor((this.lastFiredTickElapsed * this.tickRateLimit) / 1000) <
+                Math.floor((elapsed * this.tickRateLimit) / 1000)), tap(([elapsed]) => (this.lastFiredTickElapsed = elapsed)))
+            .subscribe(this._tick$);
     }
+    /**
+     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
+     */
     get tick$() {
-        return this._tick$.pipe(map(([oldTime, newTime]) => [newTime, newTime - oldTime]));
+        return this._tick$.asObservable();
     }
+    /**
+     * Checks if the clock is currently running.
+     */
     get isRunning() {
         return !!this.tickSub;
     }
+    /**
+     * Checks if the clock is currently paused.
+     */
     get isPaused() {
         return this.pausedAt !== -1;
     }
+    /**
+     * Checks if the clock is stopped.
+     */
+    get isStopped() {
+        return this.startedAt === -1;
+    }
+    /**
+     * Gets the time scale of the clock.
+     */
+    get timeScale() {
+        return this._timeScale;
+    }
+    /**
+     * Sets the time scale of the clock.
+     */
+    set timeScale(value) {
+        if (value === this._timeScale && !(this.pausedByTimescale && value !== 0))
+            return;
+        if (value === 0) {
+            if (!this.isPaused) {
+                this.pause();
+                this.pausedByTimescale = true;
+            }
+            return;
+        }
+        if (this.isPaused && this.pausedByTimescale) {
+            this.resume();
+            this.pausedByTimescale = false;
+        }
+        if (!this.isStopped) {
+            const cur = this.isPaused ? this.pausedAt : this.parentClock.elapsedTime;
+            this.startedAt = cur - ((cur - this.startedAt) * this.timeScale) / value;
+        }
+        this._timeScale = value;
+    }
+    /**
+     * Gets the elapsed time since the clock started.
+     */
     get elapsedTime() {
+        if (this.isStopped) {
+            return this.lastStopElapsed;
+        }
         if (this.isPaused) {
-            return this.pausedAt - this.startedAt;
+            return this._timeScale * (this.pausedAt - this.startedAt);
         }
-        return this.parentClock.elapsedTime - this.startedAt;
+        return this._timeScale * (this.parentClock.elapsedTime - this.startedAt);
     }
+    /**
+     * Creates a child clock.
+     * @param autoStart Indicates whether the child clock should start automatically.
+     * @returns A new instance of PausableClock.
+     */
     createChildClock(autoStart) {
         return new PausableClock(autoStart, this);
     }
+    /**
+     * Starts the clock.
+     */
     start() {
         if (this.isRunning) {
             return;
@@ -43,14 +120,25 @@ export class PausableClock {
         this.startedAt = this.parentClock.elapsedTime;
         this.startListeningTicks();
     }
+    /**
+     * Stops the clock.
+     */
     stop() {
         this.stopListeningTicks();
+        this.lastStopElapsed = this.elapsedTime;
         this.startedAt = this.pausedAt = -1;
     }
+    /**
+     * Pauses the clock.
+     */
     pause() {
         this.stopListeningTicks();
         this.pausedAt = this.parentClock.elapsedTime;
+        this.pausedByTimescale = false;
     }
+    /**
+     * Resumes the clock.
+     */
     resume() {
         if (this.isRunning || this.pausedAt == -1) {
             return;
@@ -59,14 +147,20 @@ export class PausableClock {
         this.pausedAt = -1;
         this.startListeningTicks();
     }
+    /**
+     * Starts listening for ticks from the parent clock.
+     */
     startListeningTicks() {
         if (this.tickSub) {
             throw new Error('Clock is already ticking!');
         }
         this.tickSub = this.parentClock.tick$
-            .pipe(map(([parentElapsed, _]) => [this.oldRelativeTime, parentElapsed - this.startedAt]), tap(([_, cur]) => (this.oldRelativeTime = cur)))
-            .subscribe(this._tick$);
+            .pipe(map(([_, d]) => [this.oldRelativeTime, this.oldRelativeTime + d * this.timeScale]), tap(([_, cur]) => (this.oldRelativeTime = cur)))
+            .subscribe(this._internalTick$);
     }
+    /**
+     * Stops listening for ticks from the parent clock.
+     */
     stopListeningTicks() {
         var _a;
         (_a = this.tickSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();

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

@@ -1,7 +1,7 @@
 import { IEntity } from '../../entities/i-entity';
 import { IWorldComponent } from '../i-world-component';
 import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../../gg-world';
-import { CollisionGroup } from '../../models/body-options';
+import { CollisionGroup, DebugBodySettings } from '../../models/body-options';
 export interface IBodyComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IWorldComponent<D, R, VisualTypeDocRepo<D, R>, TypeDoc> {
     entity: IEntity | null;
     position: D;
@@ -11,6 +11,8 @@ export interface IBodyComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> =
     set ownCollisionGroups(value: CollisionGroup[] | 'all');
     get interactWithCollisionGroups(): CollisionGroup[];
     set interactWithCollisionGroups(value: CollisionGroup[] | 'all');
+    /** body info for physics debugger view */
+    readonly debugBodySettings: DebugBodySettings;
     clone(): IBodyComponent<D, R, TypeDoc>;
     addToWorld(world: GgWorld<D, R, VisualTypeDocRepo<D, R>, TypeDoc>): void;
     removeFromWorld(world: GgWorld<D, R, VisualTypeDocRepo<D, R>, TypeDoc>): void;