@gg-web-engine/core 0.0.49 → 0.0.57

package/dist/3d/entities/surface-following.entity.d.ts

@@ -0,0 +1,96 @@
+import { BodyOptions, IEntity, Point3, Point4 } from '../../base';
+import { Gg3dWorld, PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
+import { Shape3DDescriptor } from '../models/shapes';
+/**
+ * Represents a function that calculates the surface position and normal
+ * for a given point in 3D space.
+ */
+export type SurfaceFollowFunc = (p: Point3) => {
+    position: Point3;
+    normal: Point3;
+};
+/**
+ * Represents an entity that follows a surface dynamically by adjusting
+ * its position and orientation based on a given surface function.
+ *
+ * @template PTypeDoc - The physics type document repository.
+ */
+export declare class SurfaceFollowingEntity<PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IEntity<Point3, Point4, VisualTypeDocRepo3D, PTypeDoc> {
+    /** Function that determines surface position and normal. */
+    followFunc: SurfaceFollowFunc;
+    /** Optional body configuration. */
+    protected bodyOptions: Partial<Omit<BodyOptions, 'dynamic' | 'mass' | 'ownCollisionGroups' | 'interactWithCollisionGroups'>>;
+    /**
+     * Determines the execution order for physics simulation.
+     */
+    readonly tickOrder: number;
+    /**
+     * Debugging settings for the surface-following entity.
+     */
+    readonly debugBodySettings: SurfaceFollowingEntityDebugSettings;
+    constructor(
+    /** Function that determines surface position and normal. */
+    followFunc: SurfaceFollowFunc, 
+    /** Optional body configuration. */
+    bodyOptions?: Partial<Omit<BodyOptions, 'dynamic' | 'mass' | 'ownCollisionGroups' | 'interactWithCollisionGroups'>>);
+    /**
+     * Stores colliders and their associated metadata.
+     */
+    private colliders;
+    /**
+     * Sets up a collider by assigning it a collision group and a dynamic plane.
+     *
+     * @param collider - The physics rigid body to configure.
+     */
+    private setupCollider;
+    /**
+     * Adds a collider to the entity, registering it immediately if the entity
+     * is already in a world.
+     *
+     * @param collider - The physics rigid body to add.
+     */
+    addCollider(collider: PTypeDoc['rigidBody']): void;
+    /**
+     * Removes a collider and deregisters its associated collision group.
+     *
+     * @param collider - The physics rigid body to remove.
+     */
+    removeCollider(collider: PTypeDoc['rigidBody']): void;
+    /**
+     * Called when the entity is added to a world.
+     *
+     * @param world - The game world instance.
+     */
+    onSpawned(world: Gg3dWorld<VisualTypeDocRepo3D, PTypeDoc>): void;
+    private customGlobalDebugDummyBody;
+    /**
+     * Updates debug visualization if active.
+     */
+    private updateDebugView;
+    /**
+     * Called when the entity is removed from the world.
+     */
+    onRemoved(): void;
+    /**
+     * Positions planes based on the surface-follow function.
+     */
+    protected positionPlanes(): void;
+}
+/**
+ * Stores debug settings for a SurfaceFollowingEntity, allowing customization
+ * of the debug mesh.
+ */
+export declare class SurfaceFollowingEntityDebugSettings {
+    private _hexMeshStepDistance;
+    private _hexMeshDepth;
+    private _customGlobalShape;
+    private _revision;
+    get revision(): number;
+    get hexMeshStepDistance(): number;
+    set hexMeshStepDistance(value: number);
+    get hexMeshDepth(): number;
+    set hexMeshDepth(value: number);
+    get customGlobalShape(): Shape3DDescriptor | null;
+    set customGlobalShape(value: Shape3DDescriptor | null);
+    constructor(_hexMeshStepDistance?: number, _hexMeshDepth?: number, _customGlobalShape?: Shape3DDescriptor | null);
+}

package/dist/3d/entities/surface-following.entity.js

@@ -0,0 +1,296 @@
+import { takeUntil } from 'rxjs';
+import { IEntity, Pnt2, Pnt3, Qtrn, TickOrder } from '../../base';
+/**
+ * Represents an entity that follows a surface dynamically by adjusting
+ * its position and orientation based on a given surface function.
+ *
+ * @template PTypeDoc - The physics type document repository.
+ */
+export class SurfaceFollowingEntity extends IEntity {
+    constructor(
+    /** Function that determines surface position and normal. */
+    followFunc, 
+    /** Optional body configuration. */
+    bodyOptions = {}) {
+        super();
+        this.followFunc = followFunc;
+        this.bodyOptions = bodyOptions;
+        /**
+         * Determines the execution order for physics simulation.
+         */
+        this.tickOrder = TickOrder.PHYSICS_SIMULATION - 1;
+        /**
+         * Debugging settings for the surface-following entity.
+         */
+        this.debugBodySettings = new SurfaceFollowingEntityDebugSettings();
+        /**
+         * Stores colliders and their associated metadata.
+         */
+        this.colliders = new Map();
+        this.customGlobalDebugDummyBody = null;
+    }
+    /**
+     * Sets up a collider by assigning it a collision group and a dynamic plane.
+     *
+     * @param collider - The physics rigid body to configure.
+     */
+    setupCollider(collider) {
+        if (!this.world) {
+            throw new Error('Cannot setup collider if not added to the world');
+        }
+        let cg = this.world.physicsWorld.registerCollisionGroup();
+        collider.ownCollisionGroups = [...collider.ownCollisionGroups, cg];
+        collider.interactWithCollisionGroups = [...collider.ownCollisionGroups, cg];
+        let plane = this.world.physicsWorld.factory.createRigidBody({
+            shape: { shape: 'PLANE' },
+            body: Object.assign(Object.assign({}, this.bodyOptions), { dynamic: false, ownCollisionGroups: [cg], interactWithCollisionGroups: [cg] }),
+        });
+        if (this.debugBodySettings.customGlobalShape) {
+            plane.debugBodySettings.shape = { shape: 'SPHERE', radius: 0.25 };
+        }
+        else {
+            plane.debugBodySettings.ignoreTransform = true;
+        }
+        this.addComponents(plane);
+        this.colliders.set(collider, [cg, plane, {}]);
+    }
+    /**
+     * Adds a collider to the entity, registering it immediately if the entity
+     * is already in a world.
+     *
+     * @param collider - The physics rigid body to add.
+     */
+    addCollider(collider) {
+        if (this.world) {
+            this.setupCollider(collider);
+        }
+        else {
+            this.colliders.set(collider, null);
+        }
+    }
+    /**
+     * Removes a collider and deregisters its associated collision group.
+     *
+     * @param collider - The physics rigid body to remove.
+     */
+    removeCollider(collider) {
+        if (!this.colliders.has(collider)) {
+            return;
+        }
+        const item = this.colliders.get(collider);
+        if (item) {
+            const [cg, plane] = item;
+            this.removeComponents([plane], true);
+            collider.ownCollisionGroups = collider.ownCollisionGroups.filter(g => g !== cg);
+            collider.interactWithCollisionGroups = collider.interactWithCollisionGroups.filter(g => g !== cg);
+            this.world.physicsWorld.deregisterCollisionGroup(cg);
+        }
+        this.colliders.delete(collider);
+    }
+    /**
+     * Called when the entity is added to a world.
+     *
+     * @param world - The game world instance.
+     */
+    onSpawned(world) {
+        super.onSpawned(world);
+        for (const [collider] of this.colliders.entries()) {
+            this.setupCollider(collider);
+        }
+        world.physicsWorld.removed$.pipe(takeUntil(this.onRemoved$)).subscribe(c => {
+            if (this.colliders.has(c)) {
+                this.removeCollider(c);
+            }
+        });
+        this.tick$.pipe(takeUntil(this.onRemoved$)).subscribe(() => {
+            this.positionPlanes();
+            this.updateDebugView();
+        });
+        this.positionPlanes();
+        this.updateDebugView();
+    }
+    /**
+     * Updates debug visualization if active.
+     */
+    updateDebugView() {
+        const updateDebugView = !!this.world.renderers.find(r => r.physicsDebugViewActive);
+        if (updateDebugView) {
+            if (this.debugBodySettings.customGlobalShape) {
+                if (!this.customGlobalDebugDummyBody) {
+                    this.customGlobalDebugDummyBody = this.world.physicsWorld.factory.createRigidBody({
+                        shape: { shape: 'BOX', dimensions: Pnt3.O },
+                        body: { dynamic: false },
+                    });
+                    this.customGlobalDebugDummyBody.ownCollisionGroups = [];
+                    this.customGlobalDebugDummyBody.interactWithCollisionGroups = [];
+                    this.customGlobalDebugDummyBody.debugBodySettings.type = { type: 'RIGID_STATIC' };
+                    this.customGlobalDebugDummyBody.debugBodySettings.shape = this.debugBodySettings.customGlobalShape;
+                    this.addComponents(this.customGlobalDebugDummyBody);
+                    for (const item of this.colliders.values()) {
+                        if (item) {
+                            let [_, plane] = item;
+                            plane.debugBodySettings.shape = { shape: 'SPHERE', radius: 0.25 };
+                            plane.debugBodySettings.ignoreTransform = false;
+                        }
+                    }
+                }
+                else {
+                    this.customGlobalDebugDummyBody.debugBodySettings.shape = this.debugBodySettings.customGlobalShape;
+                }
+            }
+            else {
+                if (this.customGlobalDebugDummyBody) {
+                    this.removeComponents([this.customGlobalDebugDummyBody], true);
+                    this.customGlobalDebugDummyBody = null;
+                    // reset caches
+                    for (const item of this.colliders.values()) {
+                        if (item) {
+                            item[2] = {};
+                        }
+                    }
+                }
+                for (const [collider, item] of this.colliders.entries()) {
+                    let [_, plane, debugCache] = item;
+                    const { position, normal } = this.followFunc(collider.position);
+                    let xThreshold = this.debugBodySettings.hexMeshStepDistance;
+                    let yThreshold = this.debugBodySettings.hexMeshStepDistance * Math.sqrt(3);
+                    let zThreshold = this.debugBodySettings.hexMeshStepDistance * 2;
+                    let hexMeshStartPosition = {
+                        x: Math.round(position.x / xThreshold) * xThreshold,
+                        y: Math.round(position.y / yThreshold) * yThreshold,
+                        z: Math.round(position.z / zThreshold) * zThreshold,
+                    };
+                    if (debugCache.lastDebugSettingsRev != this.debugBodySettings.revision ||
+                        !debugCache.lastDebugStartPos ||
+                        Pnt3.dist(debugCache.lastDebugStartPos, hexMeshStartPosition) > 1) {
+                        let { vertices, faces } = buildHexMeshAlongSurface(hexMeshStartPosition, this.followFunc, this.debugBodySettings.hexMeshDepth, this.debugBodySettings.hexMeshStepDistance);
+                        plane.debugBodySettings.shape = {
+                            shape: 'MESH',
+                            vertices,
+                            faces,
+                        };
+                        plane.debugBodySettings.ignoreTransform = true;
+                        debugCache.lastDebugStartPos = hexMeshStartPosition;
+                        debugCache.lastDebugSettingsRev = this.debugBodySettings.revision;
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Called when the entity is removed from the world.
+     */
+    onRemoved() {
+        for (const [collider, item] of this.colliders) {
+            if (item) {
+                const [cg, plane] = item;
+                this.removeComponents([plane], true);
+                collider.ownCollisionGroups = collider.ownCollisionGroups.filter(g => g !== cg);
+                collider.interactWithCollisionGroups = collider.interactWithCollisionGroups.filter(g => g !== cg);
+                this.world.physicsWorld.deregisterCollisionGroup(cg);
+            }
+        }
+        this.colliders.clear();
+        super.onRemoved();
+    }
+    /**
+     * Positions planes based on the surface-follow function.
+     */
+    positionPlanes() {
+        if (!this.world) {
+            return;
+        }
+        for (const [collider, item] of this.colliders.entries()) {
+            let [_, plane] = item;
+            const { position, normal } = this.followFunc(collider.position);
+            plane.position = position;
+            plane.rotation = Qtrn.lookAt(normal, Pnt3.O);
+        }
+    }
+}
+/**
+ * Stores debug settings for a SurfaceFollowingEntity, allowing customization
+ * of the debug mesh.
+ */
+export class SurfaceFollowingEntityDebugSettings {
+    get revision() {
+        return this._revision;
+    }
+    get hexMeshStepDistance() {
+        return this._hexMeshStepDistance;
+    }
+    set hexMeshStepDistance(value) {
+        this._hexMeshStepDistance = value;
+        this._revision++;
+    }
+    get hexMeshDepth() {
+        return this._hexMeshDepth;
+    }
+    set hexMeshDepth(value) {
+        this._hexMeshDepth = value;
+        this._revision++;
+    }
+    get customGlobalShape() {
+        return this._customGlobalShape;
+    }
+    set customGlobalShape(value) {
+        this._customGlobalShape = value;
+        this._revision++;
+    }
+    constructor(_hexMeshStepDistance = 4, _hexMeshDepth = 6, _customGlobalShape = null) {
+        this._hexMeshStepDistance = _hexMeshStepDistance;
+        this._hexMeshDepth = _hexMeshDepth;
+        this._customGlobalShape = _customGlobalShape;
+        this._revision = 0;
+    }
+}
+const buildHexMeshAlongSurface = (start, surfaceFunc, depth, stepDistance) => {
+    let startPoint = surfaceFunc(start);
+    const vertices = [startPoint.position];
+    const faces = [];
+    let lastLoop = [
+        {
+            position: startPoint.position,
+            normal: startPoint.normal,
+            vertexIndex: 0,
+        },
+    ];
+    const traverse = (point, angle) => {
+        let pnt2 = Pnt2.rot(Pnt2.scalarMult(Pnt2.X, stepDistance), angle);
+        let snorm = Pnt3.toSpherical(point.normal);
+        let spnt = Pnt3.toSpherical(Object.assign(Object.assign({}, pnt2), { z: 0 }));
+        return Pnt3.add(point.position, Pnt3.fromSpherical(Object.assign(Object.assign({}, spnt), { phi: spnt.phi + Math.cos(snorm.theta - spnt.theta) * snorm.phi })));
+    };
+    for (let i = 0; i < depth; i++) {
+        let newLoop = [];
+        if (i == 0) {
+            for (let j = 0; j < 6; j++) {
+                let point = surfaceFunc(traverse(startPoint, (j * Math.PI) / 3));
+                newLoop.push(Object.assign(Object.assign({}, point), { vertexIndex: j + 1 }));
+                faces.push([0, j + 1, j < 5 ? j + 2 : 1]);
+            }
+        }
+        else {
+            for (let j = 0; j < lastLoop.length; j++) {
+                let startPoint = lastLoop[j];
+                let angle = (Math.floor((j * 6) / lastLoop.length) * Math.PI) / 3;
+                let rightNeighbour = lastLoop[j < lastLoop.length - 1 ? j + 1 : 0];
+                if (j % (lastLoop.length / 6) == 0) {
+                    // hex corner vertex, add new vertex in this loop. Each next loop has +6 vertices
+                    let pointF = surfaceFunc(traverse(startPoint, angle));
+                    let vi = vertices.length + newLoop.length;
+                    newLoop.push(Object.assign(Object.assign({}, pointF), { vertexIndex: vi }));
+                    faces.push([startPoint.vertexIndex, j > 0 ? vi - 1 : vi + lastLoop.length + 5, vi]);
+                }
+                let pointR = surfaceFunc(Pnt3.avg(traverse(startPoint, angle + Math.PI / 3), traverse(rightNeighbour, angle)));
+                let vi = vertices.length + newLoop.length;
+                newLoop.push(Object.assign(Object.assign({}, pointR), { vertexIndex: vi }));
+                faces.push([startPoint.vertexIndex, vi - 1, vi]);
+                faces.push([rightNeighbour.vertexIndex, startPoint.vertexIndex, vi]);
+            }
+        }
+        vertices.push(...newLoop.map(({ position }) => position));
+        lastLoop = newLoop;
+    }
+    return { vertices, faces };
+};

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

@@ -36,4 +36,7 @@ export declare class Gg3dWorld<VTypeDoc extends VisualTypeDocRepo3D = VisualType
     constructor(visualScene: VS, physicsWorld: PW);
     addPrimitiveRigidBody(descr: BodyShape3DDescriptor, position?: Point3, rotation?: Point4, material?: DisplayObject3dOpts<VTypeDoc['texture']>): Entity3d<VTypeDoc, PTypeDoc>;
     addRenderer(camera: VTypeDoc['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & VTypeDoc['rendererExtraOpts']>): Renderer3dEntity<VTypeDoc>;
+    protected registerConsoleCommands(ggstatic: {
+        registerConsoleCommand: (world: GgWorld<any, any> | null, command: string, handler: (...args: string[]) => Promise<string>, doc?: string) => void;
+    }): void;
 }

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

@@ -17,21 +17,12 @@ export class Gg3dWorld extends GgWorld {
         this.visualScene = visualScene;
         this.physicsWorld = physicsWorld;
         this.loader = new Gg3dLoader(this);
-        if (window.ggstatic) {
-            window.ggstatic.registerConsoleCommand(this, 'ph_gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
-                if (args.length == 1) {
-                    args = ['0', '0', '' + -+args[0]]; // mean -Z axis
-                }
-                if (args.length > 0) {
-                    this.physicsWorld.gravity = { x: +args[0], y: +args[1], z: +args[2] };
-                }
-                return JSON.stringify(this.physicsWorld.gravity);
-            }), 'args: [float] or [float float float]; change 3D world gravity vector. 1 argument means ' +
-                '{x: 0, y: 0, z: -value}, 3 arguments set the whole vector. Default value is "9.82" or "0 0 -9.82"');
-        }
     }
     addPrimitiveRigidBody(descr, position = Pnt3.O, rotation = Qtrn.O, material = {}) {
-        const entity = new Entity3d(this.visualScene.factory.createPrimitive(descr.shape, material), this.physicsWorld.factory.createRigidBody(descr));
+        const entity = new Entity3d({
+            object3D: this.visualScene.factory.createPrimitive(descr.shape, material),
+            objectBody: this.physicsWorld.factory.createRigidBody(descr),
+        });
         entity.position = position;
         entity.rotation = rotation;
         this.addEntity(entity);
@@ -42,4 +33,21 @@ export class Gg3dWorld extends GgWorld {
         this.addEntity(entity);
         return entity;
     }
+    registerConsoleCommands(ggstatic) {
+        super.registerConsoleCommands(ggstatic);
+        ggstatic.registerConsoleCommand(this, 'gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
+            if (args.length == 1) {
+                args = ['0', '0', '' + -+args[0]]; // mean -Z axis
+            }
+            if (args.length > 0) {
+                if (isNaN(+args[0]) || isNaN(+args[1]) || isNaN(+args[2])) {
+                    throw new Error('Wrong arguments');
+                }
+                this.physicsWorld.gravity = { x: +args[0], y: +args[1], z: +args[2] };
+            }
+            return JSON.stringify(this.physicsWorld.gravity);
+        }), 'args: [ ?float, ?float, ?float ]; Get or set 3D world gravity vector. 1 argument sets ' +
+            'vector {x: 0, y: 0, z: -value}, 3 arguments set the whole vector.' +
+            ' Default value is "9.82" or "0 0 -9.82"');
+    }
 }

package/dist/3d/index.d.ts

@@ -19,6 +19,7 @@ export * from './entities/controllers/input/car-keyboard-handling.controller';
 export * from './entities/controllers/input/gg-car-keyboard-handling.controller';
 export * from './entities/controllers/input/free-camera.controller';
 export * from './entities/controllers/input/orbit-camera.controller';
+export * from './entities/surface-following.entity';
 export * from './interfaces/i-positionable-3d';
 export * from './models/body-options';
 export * from './models/gg-meta';

package/dist/3d/index.js

@@ -19,6 +19,7 @@ export * from './entities/controllers/input/car-keyboard-handling.controller';
 export * from './entities/controllers/input/gg-car-keyboard-handling.controller';
 export * from './entities/controllers/input/free-camera.controller';
 export * from './entities/controllers/input/orbit-camera.controller';
+export * from './entities/surface-following.entity';
 export * from './interfaces/i-positionable-3d';
 export * from './models/body-options';
 export * from './models/gg-meta';

package/dist/3d/loader.js

@@ -99,7 +99,7 @@ export class Gg3dLoader {
             const loadOptions = Object.assign(Object.assign({}, defaultLoadOptions), options);
             const { resources, meta } = yield this.loadGgGlbResources(path, loadOptions.cachingStrategy);
             const result = {
-                entities: resources.map(({ object3D, body }) => new Entity3d(object3D, body)),
+                entities: resources.map(x => new Entity3d({ object3D: x.object3D, objectBody: x.body })),
                 meta,
             };
             if (loadOptions.loadProps) {

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

@@ -1,7 +1,7 @@
-import { BodyOptions, DebugBodySettings } from '../../base';
+import { BodyOptions, DebugBodySettings, DebugBodyType } from '../../base';
 import { Shape3DDescriptor } from './shapes';
 export interface Body3DOptions extends BodyOptions {
 }
-export type DebugBody3DSettings = DebugBodySettings & {
-    shape: Shape3DDescriptor;
-};
+export declare class DebugBody3DSettings extends DebugBodySettings<Shape3DDescriptor> {
+    constructor(type: DebugBodyType, shape: Shape3DDescriptor, ignoreTransform?: boolean, color?: number | undefined);
+}

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

@@ -1 +1,6 @@
-export {};
+import { DebugBodySettings } from '../../base';
+export class DebugBody3DSettings extends DebugBodySettings {
+    constructor(type, shape, ignoreTransform = false, color = undefined) {
+        super(type, shape, ignoreTransform, color);
+    }
+}

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

@@ -1,16 +1,12 @@
-import { Observable } from 'rxjs';
-import { PausableClock } from './pausable-clock';
 import { IClock } from './i-clock';
 /**
  * A singleton class, providing ability to track time, fire ticks, provide time elapsed + tick delta.
  * Starts as soon as accessed and counts time from 01/01/1970
  */
-export declare class GgGlobalClock implements IClock {
+export declare class GgGlobalClock extends IClock {
     private static _instance;
     static get instance(): GgGlobalClock;
-    private readonly _tick$;
-    get tick$(): Observable<[number, number]>;
     get elapsedTime(): number;
-    createChildClock(autoStart: boolean): PausableClock;
     private constructor();
+    dispose(): void;
 }

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

@@ -1,32 +1,32 @@
-import { animationFrameScheduler, of, Subject } from 'rxjs';
-import { map, repeat, tap } from 'rxjs/operators';
-import { PausableClock } from './pausable-clock';
+import { IClock } from './i-clock';
+const now = typeof performance === 'undefined' ? () => Date.now() : () => performance.now();
 /**
  * A singleton class, providing ability to track time, fire ticks, provide time elapsed + tick delta.
  * Starts as soon as accessed and counts time from 01/01/1970
  */
-export class GgGlobalClock {
+export class GgGlobalClock extends IClock {
     static get instance() {
         if (!GgGlobalClock._instance) {
             GgGlobalClock._instance = new GgGlobalClock();
         }
         return GgGlobalClock._instance;
     }
-    get tick$() {
-        return this._tick$.pipe(map(([oldTime, newTime]) => [newTime, newTime - oldTime]));
-    }
     get elapsedTime() {
-        return (typeof performance === 'undefined' ? Date : performance).now();
-    }
-    createChildClock(autoStart) {
-        return new PausableClock(autoStart, this);
+        return now();
     }
     constructor() {
-        this._tick$ = new Subject();
+        super(null);
         let oldRelativeTime = this.elapsedTime;
-        of(undefined, animationFrameScheduler)
-            .pipe(repeat())
-            .pipe(map(() => [oldRelativeTime, this.elapsedTime]), tap(([_, cur]) => (oldRelativeTime = cur)))
-            .subscribe(this._tick$);
+        const tick = () => {
+            requestAnimationFrame(tick);
+            const prev = oldRelativeTime;
+            const cur = this.elapsedTime;
+            oldRelativeTime = cur;
+            this._tick$.next([prev, cur - prev]);
+        };
+        requestAnimationFrame(tick);
+    }
+    dispose() {
+        throw new Error('Cannot dispose global clock');
     }
 }

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

@@ -1,7 +1,16 @@
-import { Observable } from 'rxjs';
-import { PausableClock } from './pausable-clock';
-export interface IClock {
+import { Observable, Subject } from 'rxjs';
+export declare abstract class IClock {
+    readonly parent: IClock | null;
+    protected readonly _tick$: Subject<[number, number]>;
+    /**
+     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
+     */
     get tick$(): Observable<[number, number]>;
-    get elapsedTime(): number;
-    createChildClock(autoStart: boolean): PausableClock;
+    abstract get elapsedTime(): number;
+    protected _children: IClock[];
+    get children(): IClock[];
+    protected constructor(parent: IClock | null);
+    addChild(clock: IClock): void;
+    removeChild(clock: IClock): void;
+    dispose(): void;
 }

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

@@ -1 +1,43 @@
-export {};
+import { Subject } from 'rxjs';
+export class IClock {
+    /**
+     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
+     */
+    get tick$() {
+        return this._tick$.asObservable();
+    }
+    get children() {
+        return [...this._children];
+    }
+    constructor(parent) {
+        this.parent = parent;
+        this._tick$ = new Subject();
+        this._children = [];
+        if (parent) {
+            parent.addChild(this);
+        }
+    }
+    addChild(clock) {
+        if (clock.parent !== this) {
+            throw new Error('Incorrect child clock');
+        }
+        if (!this._children.includes(clock)) {
+            this._children.push(clock);
+        }
+    }
+    removeChild(clock) {
+        if (clock.parent !== this) {
+            throw new Error('Incorrect child clock');
+        }
+        this._children = this._children.filter(c => c !== clock);
+    }
+    dispose() {
+        if (this.parent) {
+            this.parent.removeChild(this);
+        }
+        for (const c of this._children) {
+            c.dispose();
+        }
+        this._tick$.complete();
+    }
+}

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

@@ -1,17 +1,12 @@
-import { Observable, Subject } from 'rxjs';
+import { Subject } from 'rxjs';
 import { IClock } from './i-clock';
 /**
  * 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 {
+export declare class PausableClock extends 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.
      */
@@ -54,12 +49,6 @@ export declare class PausableClock implements IClock {
      * @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.
      */
@@ -84,4 +73,5 @@ export declare class PausableClock implements IClock {
      * Stops listening for ticks from the parent clock.
      */
     protected stopListeningTicks(): void;
+    dispose(): void;
 }