@gg-web-engine/core 0.0.4 → 0.0.5

package/dist/2d/entities/gg-2d-entity.js

@@ -104,7 +104,6 @@ class Gg2dEntity extends gg_positionable_2d_entity_1.GgPositionable2dEntity {
     }
     dispose() {
         super.dispose();
-        this.tick$.unsubscribe();
         if (this.object2D) {
             this.object2D.dispose();
         }

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

@@ -104,7 +104,6 @@ class Gg3dEntity extends gg_positionable_3d_entity_1.GgPositionable3dEntity {
     }
     dispose() {
         super.dispose();
-        this.tick$.unsubscribe();
         if (this.object3D) {
             this.object3D.dispose();
         }

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

@@ -13,7 +13,23 @@ export declare type MapGraphNodeType = {
     loadOptions: Partial<Omit<LoadOptions, 'position' | 'rotation'>>;
 };
 export declare class MapGraph extends Graph<MapGraphNodeType> {
-    static fromMapArray(array: MapGraphNodeType[]): MapGraph;
+    /**
+     * Creates a new MapGraph instance from an array of elements, where each element in the array is a node in the graph.
+     * The first element of the array is used as the root node of the graph.
+     * @param array The array of elements to create the graph from.
+     * @param closed An optional boolean indicating whether the graph is closed, meaning that the last node is adjacent to the first node.
+     * @returns A new Graph instance created from the array.
+     * @typeparam T The type of elements in the array and nodes in the graph.
+     */
+    static fromMapArray(array: MapGraphNodeType[], closed?: boolean): MapGraph;
+    /**
+     * Creates a new MapGraph instance from a two-dimensional square grid of elements, where each element in the grid is a node in the graph.
+     * The top-left element of the grid is used as the root node of the graph.
+     * The nodes in the graph are created in the same order as the elements in the grid, from left to right and then from top to bottom.
+     * @param grid The two-dimensional square grid of elements to create the graph from.
+     * @returns A new Graph instance created from the square grid.
+     * @typeparam T The type of elements in the square grid and nodes in the graph.
+     */
     static fromMapSquareGrid(grid: MapGraphNodeType[][]): MapGraph;
     getNearestDummy(thisNodes: Graph<MapGraphNodeType>[], cursor: Point3): Graph<MapGraphNodeType>;
     nodes(): MapGraph[];

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

@@ -15,7 +15,15 @@ const operators_1 = require("rxjs/operators");
 const graph_1 = require("../../base/data-structures/graph");
 const gg_entity_1 = require("../../base/entities/gg-entity");
 class MapGraph extends graph_1.Graph {
-    static fromMapArray(array) {
+    /**
+     * Creates a new MapGraph instance from an array of elements, where each element in the array is a node in the graph.
+     * The first element of the array is used as the root node of the graph.
+     * @param array The array of elements to create the graph from.
+     * @param closed An optional boolean indicating whether the graph is closed, meaning that the last node is adjacent to the first node.
+     * @returns A new Graph instance created from the array.
+     * @typeparam T The type of elements in the array and nodes in the graph.
+     */
+    static fromMapArray(array, closed = false) {
         const root = new MapGraph(array[0]);
         let tail = root;
         for (let i = 1; i < array.length; i++) {
@@ -23,8 +31,19 @@ class MapGraph extends graph_1.Graph {
             tail.addAdjacent(newTail);
             tail = newTail;
         }
+        if (closed) {
+            tail.addAdjacent(root);
+        }
         return root;
     }
+    /**
+     * Creates a new MapGraph instance from a two-dimensional square grid of elements, where each element in the grid is a node in the graph.
+     * The top-left element of the grid is used as the root node of the graph.
+     * The nodes in the graph are created in the same order as the elements in the grid, from left to right and then from top to bottom.
+     * @param grid The two-dimensional square grid of elements to create the graph from.
+     * @returns A new Graph instance created from the square grid.
+     * @typeparam T The type of elements in the square grid and nodes in the graph.
+     */
     static fromMapSquareGrid(grid) {
         const nodes = grid.map(sgrid => sgrid.map(item => new MapGraph(item)));
         // bind them

package/dist/base/data-structures/graph.d.ts

@@ -1,5 +1,21 @@
 export declare class Graph<T> {
-    static fromArray<T>(array: T[]): Graph<T>;
+    /**
+     * Creates a new Graph instance from an array of elements, where each element in the array is a node in the graph.
+     * The first element of the array is used as the root node of the graph.
+     * @param array The array of elements to create the graph from.
+     * @param closed An optional boolean indicating whether the graph is closed, meaning that the last node is adjacent to the first node.
+     * @returns A new Graph instance created from the array.
+     * @typeparam T The type of elements in the array and nodes in the graph.
+     */
+    static fromArray<T>(array: T[], closed?: boolean): Graph<T>;
+    /**
+     * Creates a new Graph instance from a two-dimensional square grid of elements, where each element in the grid is a node in the graph.
+     * The top-left element of the grid is used as the root node of the graph.
+     * The nodes in the graph are created in the same order as the elements in the grid, from left to right and then from top to bottom.
+     * @param grid The two-dimensional square grid of elements to create the graph from.
+     * @returns A new Graph instance created from the square grid.
+     * @typeparam T The type of elements in the square grid and nodes in the graph.
+     */
     static fromSquareGrid<T>(grid: T[][]): Graph<T>;
     data: T;
     private adjacent;

package/dist/base/data-structures/graph.js

@@ -6,7 +6,15 @@ class Graph {
         this.data = data;
         this.adjacent = new Set();
     }
-    static fromArray(array) {
+    /**
+     * Creates a new Graph instance from an array of elements, where each element in the array is a node in the graph.
+     * The first element of the array is used as the root node of the graph.
+     * @param array The array of elements to create the graph from.
+     * @param closed An optional boolean indicating whether the graph is closed, meaning that the last node is adjacent to the first node.
+     * @returns A new Graph instance created from the array.
+     * @typeparam T The type of elements in the array and nodes in the graph.
+     */
+    static fromArray(array, closed = false) {
         const root = new Graph(array[0]);
         let tail = root;
         for (let i = 1; i < array.length; i++) {
@@ -14,8 +22,19 @@ class Graph {
             tail.addAdjacent(newTail);
             tail = newTail;
         }
+        if (closed) {
+            tail.addAdjacent(root);
+        }
         return root;
     }
+    /**
+     * Creates a new Graph instance from a two-dimensional square grid of elements, where each element in the grid is a node in the graph.
+     * The top-left element of the grid is used as the root node of the graph.
+     * The nodes in the graph are created in the same order as the elements in the grid, from left to right and then from top to bottom.
+     * @param grid The two-dimensional square grid of elements to create the graph from.
+     * @returns A new Graph instance created from the square grid.
+     * @typeparam T The type of elements in the square grid and nodes in the graph.
+     */
     static fromSquareGrid(grid) {
         const nodes = grid.map(sgrid => sgrid.map(item => new Graph(item)));
         // bind them

package/dist/base/entities/base-gg-renderer.d.ts

@@ -1,5 +1,6 @@
 import { GgEntity, GGTickOrder } from './gg-entity';
 import { Point2 } from '../models/points';
+import { GgWorld } from '../gg-world';
 export declare type RendererOptions = {
     transparent: boolean;
     background: number;
@@ -8,9 +9,12 @@ export declare type RendererOptions = {
     antialias: boolean;
 };
 export declare abstract class BaseGgRenderer extends GgEntity {
+    protected readonly canvas?: HTMLCanvasElement | undefined;
     readonly tickOrder = GGTickOrder.RENDERING;
     readonly rendererOptions: RendererOptions;
-    protected constructor(canvas?: HTMLCanvasElement, options?: Partial<RendererOptions>);
+    protected constructor(canvas?: HTMLCanvasElement | undefined, options?: Partial<RendererOptions>);
     abstract render(): void;
     abstract resize(newSize: Point2): void;
+    onSpawned(world: GgWorld<any, any>): void;
+    onRemoved(): void;
 }

package/dist/base/entities/base-gg-renderer.js

@@ -6,16 +6,28 @@ const gg_viewport_manager_1 = require("../gg-viewport-manager");
 class BaseGgRenderer extends gg_entity_1.GgEntity {
     constructor(canvas, options = {}) {
         super();
+        this.canvas = canvas;
         this.tickOrder = gg_entity_1.GGTickOrder.RENDERING;
         this.rendererOptions = Object.assign({ transparent: false, background: 0x000000, antialias: true }, (options || {}));
-        if (canvas) {
-            setTimeout(() => {
-                gg_viewport_manager_1.GgViewportManager.instance.assignRendererToCanvas(this, canvas).then();
-            }, 0);
-        }
         this.tick$.subscribe(() => {
             this.render();
         });
     }
+    onSpawned(world) {
+        super.onSpawned(world);
+        if (this.canvas) {
+            setTimeout(() => {
+                gg_viewport_manager_1.GgViewportManager.instance.assignRendererToCanvas(this, this.canvas).then();
+            }, 0);
+        }
+    }
+    onRemoved() {
+        super.onRemoved();
+        if (this.canvas) {
+            setTimeout(() => {
+                gg_viewport_manager_1.GgViewportManager.instance.deregisterCanvas(this.canvas).then();
+            }, 0);
+        }
+    }
 }
 exports.BaseGgRenderer = BaseGgRenderer;

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

@@ -13,6 +13,7 @@ export declare enum GGTickOrder {
     POST_RENDERING = 1200
 }
 export declare abstract class GgEntity {
+    private static default_name_counter;
     /**
      * will receive [elapsed time, delta] of each world clock tick
      */

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

@@ -25,7 +25,7 @@ class GgEntity {
          * a world reference, where this entity was added to
          */
         this._world = null;
-        this._name = '';
+        this._name = '0x' + (GgEntity.default_name_counter++).toString(16);
         /**
          * The flag whether entity should listen to ticks. If set to false, ticks will not be propagated to this entity
          * */
@@ -94,3 +94,4 @@ class GgEntity {
     }
 }
 exports.GgEntity = GgEntity;
+GgEntity.default_name_counter = 0;

package/dist/base/gg-viewport-manager.d.ts

@@ -14,5 +14,6 @@ export declare class GgViewportManager {
     private getStageAsync;
     createCanvas(zIndex: number): Promise<HTMLCanvasElement>;
     registerCanvas(canvas: HTMLCanvasElement, zIndex: number): Promise<void>;
+    deregisterCanvas(canvas: HTMLCanvasElement): Promise<void>;
     assignRendererToCanvas(renderer: BaseGgRenderer, canvas: HTMLCanvasElement): Promise<void>;
 }

package/dist/base/gg-viewport-manager.js

@@ -97,6 +97,16 @@ class GgViewportManager {
             canvas.height = size.y;
         });
     }
+    deregisterCanvas(canvas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const index in this.canvases) {
+                if (this.canvases[index].canvas === canvas) {
+                    delete this.canvases[index];
+                    break;
+                }
+            }
+        });
+    }
     assignRendererToCanvas(renderer, canvas) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!gg_viewport_1.GgViewport.instance.isActive) {

package/dist/base/gg-world.js

@@ -123,6 +123,7 @@ class GgWorld {
     }
     dispose() {
         this.worldClock.stop();
+        this.keyboardInput.stop().then();
         for (let i = 0; i < this.children.length; i++) {
             this.children[i].onRemoved();
             this.children[i].dispose();
@@ -151,9 +152,6 @@ class GgWorld {
             this.tickListeners.splice(this.tickListeners.findIndex(x => x === entity), 1);
             entity.onRemoved();
         }
-        else {
-            console.warn('Trying to remove entity, which is not spawned');
-        }
         if (dispose) {
             entity.dispose();
         }

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

@@ -12,4 +12,6 @@ export declare class Pnt2 {
     static scalarMult(p: Point2, m: number): Point2;
     /** linear interpolation */
     static lerp(a: Point2, b: Point2, t: number): Point2;
+    /** angle between vectors in radians */
+    static angle(a: Point2, b: Point2): number;
 }

package/dist/base/math/point2.js

@@ -36,5 +36,11 @@ class Pnt2 {
             y: a.y + t * (b.y - a.y),
         };
     }
+    /** angle between vectors in radians */
+    static angle(a, b) {
+        const dotProduct = a.x * b.x + a.y * b.y;
+        const magnitudeProduct = Math.sqrt(a.x ** 2 + a.y ** 2) * Math.sqrt(b.x ** 2 + b.y ** 2);
+        return Math.acos(dotProduct / magnitudeProduct);
+    }
 }
 exports.Pnt2 = Pnt2;

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

@@ -18,6 +18,8 @@ export declare class Pnt3 {
     static scalarMult(p: Point3, m: number): Point3;
     /** linear interpolation */
     static lerp(a: Point3, b: Point3, t: number): Point3;
+    /** angle between vectors in radians */
+    static angle(a: Point3, b: Point3): number;
     /** rotate point a with quaternion q */
     static rot(p: Point3, q: Point4): Point3;
     /** rotate point around axis a (normalized vector) */

package/dist/base/math/point3.js

@@ -61,6 +61,12 @@ class Pnt3 {
             z: a.z + t * (b.z - a.z),
         };
     }
+    /** angle between vectors in radians */
+    static angle(a, b) {
+        const dotProduct = a.x * b.x + a.y * b.y + a.z * b.z;
+        const magnitudeProduct = Math.sqrt(a.x ** 2 + a.y ** 2 + a.z ** 2) * Math.sqrt(b.x ** 2 + b.y ** 2 + b.z ** 2);
+        return Math.acos(dotProduct / magnitudeProduct);
+    }
     /** rotate point a with quaternion q */
     static rot(p, q) {
         // faster version of:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/core",
-  "version": "0.0.04",
+  "version": "0.0.05",
   "description": "An attempt to create open source game engine for browser",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",