@gg-web-engine/core 0.0.1

package/dist/base/controllers/keyboard.controller.js

@@ -0,0 +1,109 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardController = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+class KeyboardController {
+    constructor() {
+        this.bindings = {};
+        this._running = false;
+        this.handleKeys = this.handleKeys.bind(this);
+    }
+    get running() {
+        return this._running;
+    }
+    bind(code) {
+        if (!this.bindings[code]) {
+            this.bindings[code] = [];
+        }
+        const subj = new rxjs_1.BehaviorSubject(false);
+        this.bindings[code].push(subj);
+        return subj.pipe((0, rxjs_1.finalize)(() => {
+            this.bindings[code].splice(this.bindings[code].indexOf(subj), 1);
+            subj.complete();
+        }));
+    }
+    bindMany(...codes) {
+        if (codes.length == 0) {
+            console.warn('[KeyboardController] bindMany called without any key code');
+            return rxjs_1.NEVER;
+        }
+        if (codes.length == 1) {
+            return this.bind(codes[0]);
+        }
+        const subjects = [];
+        for (const code of codes) {
+            if (!this.bindings[code]) {
+                this.bindings[code] = [];
+            }
+            const subj = new rxjs_1.BehaviorSubject(false);
+            this.bindings[code].push(subj);
+            subjects.push(subj);
+        }
+        return (0, rxjs_1.combineLatest)(subjects).pipe((0, rxjs_1.finalize)(() => {
+            for (let i = 0; i < codes.length; i++) {
+                this.bindings[codes[i]].splice(this.bindings[codes[i]].indexOf(subjects[i]), 1);
+                subjects[i].complete();
+            }
+        }), (0, operators_1.map)(values => values.includes(true)));
+    }
+    emulateKeyDown(code) {
+        if (!this.running) {
+            return;
+        }
+        for (const subj of this.bindings[code] || []) {
+            subj.next(true);
+        }
+    }
+    emulateKeyUp(code) {
+        if (!this.running) {
+            return;
+        }
+        for (const subj of this.bindings[code] || []) {
+            subj.next(false);
+        }
+    }
+    emulateKeyPress(code) {
+        this.emulateKeyDown(code);
+        this.emulateKeyUp(code);
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.running) {
+                return;
+            }
+            window.addEventListener('keydown', this.handleKeys);
+            window.addEventListener('keyup', this.handleKeys);
+            this._running = true;
+        });
+    }
+    handleKeys(e) {
+        if (e.type != 'keydown' && e.type != 'keyup') {
+            return;
+        }
+        const pressed = e.type == 'keydown';
+        for (const subj of this.bindings[e.code] || []) {
+            subj.next(pressed);
+        }
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.running) {
+                return;
+            }
+            window.removeEventListener('keydown', this.handleKeys);
+            window.removeEventListener('keyup', this.handleKeys);
+            this._running = false;
+        });
+    }
+}
+exports.KeyboardController = KeyboardController;

package/dist/base/controllers/mouse.controller.d.ts

@@ -0,0 +1,24 @@
+import { IController } from './i-controller';
+import { Observable } from 'rxjs';
+import { Point2 } from '../models/points';
+export declare type MouseControllerPointLockOptions = {
+    ignoreMovementWhenNotLocked: boolean;
+    canvas: HTMLCanvasElement;
+};
+export declare type MouseControllerOptions = {
+    pointerLock?: MouseControllerPointLockOptions;
+};
+export declare class MouseController implements IController {
+    private readonly options;
+    private readonly _delta$;
+    get deltaX$(): Observable<number>;
+    get deltaY$(): Observable<number>;
+    get delta$(): Observable<Point2>;
+    constructor(options?: MouseControllerOptions);
+    private stopped$;
+    private _running;
+    get running(): boolean;
+    start(): Promise<void>;
+    private canvasClickListener;
+    stop(unlockPointer?: boolean): Promise<void>;
+}

package/dist/base/controllers/mouse.controller.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseController = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+class MouseController {
+    constructor(options = {}) {
+        this.options = options;
+        this._delta$ = new rxjs_1.Subject();
+        this.stopped$ = new rxjs_1.Subject();
+        this._running = false;
+        this.canvasClickListener = this.canvasClickListener.bind(this);
+    }
+    get deltaX$() {
+        return this._delta$.pipe((0, operators_1.map)(d => d.x));
+    }
+    get deltaY$() {
+        return this._delta$.pipe((0, operators_1.map)(d => d.y));
+    }
+    get delta$() {
+        return this._delta$.asObservable();
+    }
+    get running() {
+        return this._running;
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.running) {
+                return;
+            }
+            (0, rxjs_1.fromEvent)(window, 'mousemove')
+                .pipe((0, rxjs_1.takeUntil)(this.stopped$), (0, rxjs_1.filter)(() => !this.options.pointerLock ||
+                !this.options.pointerLock.ignoreMovementWhenNotLocked ||
+                !!document.pointerLockElement), (0, operators_1.map)((e) => ({ x: e.movementX, y: e.movementY })))
+                .subscribe(v => this._delta$.next(v));
+            if (!!this.options.pointerLock) {
+                this.options.pointerLock.canvas.addEventListener('click', this.canvasClickListener);
+            }
+            this._running = true;
+        });
+    }
+    canvasClickListener() {
+        this.options.pointerLock.canvas.requestPointerLock();
+    }
+    stop(unlockPointer = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.running) {
+                return;
+            }
+            this.stopped$.next();
+            if (unlockPointer && !!this.options.pointerLock) {
+                this.options.pointerLock.canvas.removeEventListener('click', this.canvasClickListener);
+                document.exitPointerLock();
+            }
+            this._running = false;
+        });
+    }
+}
+exports.MouseController = MouseController;

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

@@ -0,0 +1,20 @@
+export declare class Graph<T> {
+    static fromArray<T>(array: T[]): Graph<T>;
+    static fromSquareGrid<T>(grid: T[][]): Graph<T>;
+    data: T;
+    private adjacent;
+    constructor(data: T);
+    addAdjacent(node: Graph<T>): boolean;
+    removeAdjacent(node: Graph<T>): boolean;
+    /**
+     * Create an edge between two nodes
+     */
+    addEdge(source: Graph<T>, destination: Graph<T>): boolean;
+    /**
+     * Remove an edge between two nodes
+     */
+    removeEdge(source: Graph<T>, destination: Graph<T>): boolean;
+    walkRead(depth: number): Set<Graph<T>>;
+    walkReadPreserveDepth(depth: number): Set<Graph<T>>[];
+    nodes(): Graph<T>[];
+}

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Graph = void 0;
+class Graph {
+    constructor(data) {
+        this.data = data;
+        this.adjacent = new Set();
+    }
+    static fromArray(array) {
+        const root = new Graph(array[0]);
+        let tail = root;
+        for (let i = 1; i < array.length; i++) {
+            const newTail = new Graph(array[i]);
+            tail.addAdjacent(newTail);
+            tail = newTail;
+        }
+        return root;
+    }
+    static fromSquareGrid(grid) {
+        const nodes = grid.map(sgrid => sgrid.map(item => new Graph(item)));
+        // bind them
+        for (let j = 0; j < nodes.length; j++) {
+            for (let i = 0; i < nodes.length; i++) {
+                if (i > 0) {
+                    nodes[j][i].addAdjacent(nodes[j][i - 1]);
+                }
+                if (j > 0) {
+                    nodes[j][i].addAdjacent(nodes[j - 1][i]);
+                }
+            }
+        }
+        return nodes[0][0];
+    }
+    addAdjacent(node) {
+        if (this.adjacent.has(node)) {
+            return false;
+        }
+        this.adjacent.add(node);
+        node.adjacent.add(this);
+        return true;
+    }
+    removeAdjacent(node) {
+        if (!this.adjacent.has(node)) {
+            return false;
+        }
+        this.adjacent.delete(node);
+        node.adjacent.delete(this);
+        return true;
+    }
+    /**
+     * Create an edge between two nodes
+     */
+    addEdge(source, destination) {
+        if (!this.removeAdjacent(destination)) {
+            return false;
+        }
+        this.addAdjacent(source);
+        source.addAdjacent(destination);
+        return true;
+    }
+    /**
+     * Remove an edge between two nodes
+     */
+    removeEdge(source, destination) {
+        if (!source.adjacent.has(this) || !source.adjacent.has(destination)) {
+            return false;
+        }
+        source.removeAdjacent(this);
+        source.removeAdjacent(destination);
+        return this.addAdjacent(destination);
+    }
+    walkRead(depth) {
+        const visited = new Set();
+        const stack = [[this, depth]];
+        visited.add(this);
+        while (stack.length) {
+            const next = stack.shift();
+            const [node, depthLeft] = next;
+            if (depthLeft !== 0) {
+                const children = Array.from(node.adjacent).filter(c => !visited.has(c));
+                for (const child of children) {
+                    visited.add(child);
+                    stack.push([child, depthLeft - 1]);
+                }
+            }
+        }
+        return visited;
+    }
+    // the same as "walkRead", but returns array of sets (per depth), so distance to each found node can be tracked
+    walkReadPreserveDepth(depth) {
+        const visited = new Set();
+        const result = [];
+        const stack = [[this, depth]];
+        visited.add(this);
+        while (stack.length) {
+            const next = stack.shift();
+            const [node, depthLeft] = next;
+            const distance = depth - depthLeft;
+            if (!result[distance]) {
+                result[distance] = new Set();
+            }
+            result[distance].add(node);
+            if (depthLeft !== 0) {
+                const children = Array.from(node.adjacent).filter(c => !visited.has(c));
+                for (const child of children) {
+                    visited.add(child);
+                    stack.push([child, depthLeft - 1]);
+                }
+            }
+        }
+        return result;
+    }
+    // TODO return iterable?
+    nodes() {
+        return Array.from(this.walkRead(-1));
+    }
+}
+exports.Graph = Graph;

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

@@ -0,0 +1,28 @@
+import { ITickListener } from './interfaces/i-tick-listener';
+import { Subject, Subscription } from 'rxjs';
+import { GgEntity } from './gg-entity';
+import { Point2 } from '../models/points';
+export declare type RendererOptions = {
+    transparent: boolean;
+    background: number;
+    forceRendererSize?: Point2;
+    forceResolution?: number;
+    antialias: boolean;
+};
+export declare abstract class BaseGgRenderer extends GgEntity implements ITickListener {
+    protected _permanentRenderMethods: Map<number, Function>;
+    protected _singularRenderMethods: Map<number, Function>;
+    private initialized;
+    readonly tick$: Subject<[number, number]>;
+    readonly tickOrder = 1000;
+    protected tickListener: Subscription | null;
+    readonly rendererOptions: RendererOptions;
+    protected constructor(canvas?: HTMLCanvasElement, options?: Partial<RendererOptions>);
+    get isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    init(): void;
+    abstract render(): void;
+    abstract resize(newSize: Point2): void;
+    abstract dispose(): void;
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGgRenderer = void 0;
+const rxjs_1 = require("rxjs");
+const gg_entity_1 = require("./gg-entity");
+const gg_viewport_manager_1 = require("../gg-viewport-manager");
+class BaseGgRenderer extends gg_entity_1.GgEntity {
+    constructor(canvas, options = {}) {
+        super();
+        this.initialized = false;
+        this.tickOrder = 1000;
+        this.tickListener = null;
+        this.rendererOptions = Object.assign({ transparent: false, background: 0x000000, antialias: true }, (options || {}));
+        this._permanentRenderMethods = new Map();
+        this._singularRenderMethods = new Map();
+        this.tick$ = new rxjs_1.Subject();
+        if (canvas) {
+            setTimeout(() => {
+                gg_viewport_manager_1.GgViewportManager.instance.assignRendererToCanvas(this, canvas).then();
+            }, 0);
+        }
+    }
+    get isActive() {
+        return !!this.tickListener;
+    }
+    activate() {
+        if (this.isActive) {
+            return;
+        }
+        if (!this.initialized) {
+            this.init();
+        }
+        this.tickListener = this.tick$.subscribe(() => {
+            this.render();
+        });
+    }
+    deactivate() {
+        var _a;
+        if (!this.isActive) {
+            return;
+        }
+        (_a = this.tickListener) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.tickListener = null;
+    }
+    init() {
+        this.initialized = true;
+    }
+}
+exports.BaseGgRenderer = BaseGgRenderer;

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

@@ -0,0 +1,14 @@
+import { GgWorld } from '../gg-world';
+export declare abstract class GgEntity {
+    get world(): GgWorld<any, any> | null;
+    protected _world: GgWorld<any, any> | null;
+    protected _name: string;
+    get name(): string;
+    set name(value: string);
+    protected _children: GgEntity[];
+    addChildren(...entities: GgEntity[]): void;
+    removeChildren(entities: GgEntity[], dispose?: boolean): void;
+    onSpawned(world: GgWorld<any, any>): void;
+    onRemoved(): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GgEntity = void 0;
+class GgEntity {
+    constructor() {
+        this._world = null;
+        this._name = '';
+        this._children = [];
+    }
+    get world() {
+        return this._world;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    addChildren(...entities) {
+        this._children.push(...entities);
+        if (this._world) {
+            for (const item of entities) {
+                this._world.addEntity(item);
+            }
+        }
+    }
+    removeChildren(entities, dispose = false) {
+        this._children = this._children.filter(c => !entities.includes(c));
+        if (this._world) {
+            for (const item of entities) {
+                this._world.removeEntity(item, dispose);
+            }
+        }
+    }
+    onSpawned(world) {
+        this._world = world;
+        for (const c of this._children) {
+            world.addEntity(c);
+        }
+    }
+    onRemoved() {
+        const world = this._world;
+        this._world = null;
+        for (const c of this._children) {
+            world.removeEntity(c);
+        }
+    }
+    // TODO add some flag to entity that it is disposed, and throw a normal error when trying to add such entity to world again
+    dispose() {
+        for (const c of this._children) {
+            c.dispose();
+        }
+    }
+}
+exports.GgEntity = GgEntity;

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

@@ -0,0 +1,23 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { GgEntity } from './gg-entity';
+import { GgWorld } from '../gg-world';
+export declare abstract class GgPositionableEntity<D, R> extends GgEntity {
+    protected readonly _position$: BehaviorSubject<D>;
+    protected readonly _rotation$: BehaviorSubject<R>;
+    protected readonly _scale$: BehaviorSubject<D>;
+    abstract getDefaultPosition(): D;
+    abstract getDefaultRotation(): R;
+    abstract getDefaultScale(): D;
+    get world(): GgWorld<D, R> | null;
+    get position(): D;
+    get position$(): Observable<D>;
+    set position(value: D);
+    get rotation(): R;
+    get rotation$(): Observable<R>;
+    set rotation(value: R);
+    get scale(): D;
+    get scale$(): Observable<D>;
+    set scale(value: D);
+    protected constructor();
+    onSpawned(world: GgWorld<D, R>): void;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GgPositionableEntity = void 0;
+const rxjs_1 = require("rxjs");
+const gg_entity_1 = require("./gg-entity");
+class GgPositionableEntity extends gg_entity_1.GgEntity {
+    constructor() {
+        super();
+        this._position$ = new rxjs_1.BehaviorSubject(this.getDefaultPosition());
+        this._rotation$ = new rxjs_1.BehaviorSubject(this.getDefaultRotation());
+        this._scale$ = new rxjs_1.BehaviorSubject(this.getDefaultScale());
+    }
+    get world() {
+        return super.world;
+    }
+    get position() {
+        return this._position$.getValue();
+    }
+    get position$() {
+        return this._position$.asObservable();
+    }
+    set position(value) {
+        this._position$.next(value);
+    }
+    get rotation() {
+        return this._rotation$.getValue();
+    }
+    get rotation$() {
+        return this._rotation$.asObservable();
+    }
+    set rotation(value) {
+        this._rotation$.next(value);
+    }
+    get scale() {
+        return this._scale$.getValue();
+    }
+    get scale$() {
+        return this._scale$.asObservable();
+    }
+    set scale(value) {
+        this._scale$.next(value);
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+    }
+}
+exports.GgPositionableEntity = GgPositionableEntity;

package/dist/base/entities/inline-controller.d.ts

@@ -0,0 +1,3 @@
+import { GgWorld } from '../gg-world';
+import { Observable } from 'rxjs';
+export declare function createInlineTickController(world: GgWorld<any, any>, tickOrder?: number): Observable<[number, number]>;

package/dist/base/entities/inline-controller.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInlineTickController = void 0;
+const gg_entity_1 = require("./gg-entity");
+const rxjs_1 = require("rxjs");
+class InlineTickController extends gg_entity_1.GgEntity {
+    constructor(tickOrder) {
+        super();
+        this.tickOrder = tickOrder;
+        this.tick$ = new rxjs_1.Subject();
+    }
+    dispose() {
+        super.dispose();
+        this.tick$.unsubscribe();
+        this.tick$.complete();
+    }
+}
+function createInlineTickController(world, tickOrder = 750) {
+    const controller = new InlineTickController(tickOrder);
+    world.addEntity(controller);
+    return controller.tick$.pipe((0, rxjs_1.finalize)(() => {
+        world.removeEntity(controller);
+    }));
+}
+exports.createInlineTickController = createInlineTickController;

package/dist/base/entities/interfaces/i-tick-listener.d.ts

@@ -0,0 +1,7 @@
+import { Subject } from 'rxjs';
+import { GgEntity } from '../gg-entity';
+export interface ITickListener {
+    tick$: Subject<[number, number]>;
+    readonly tickOrder: number;
+}
+export declare const isITickListener: (entity: GgEntity) => boolean;

package/dist/base/entities/interfaces/i-tick-listener.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isITickListener = void 0;
+const rxjs_1 = require("rxjs");
+const isITickListener = entity => (entity === null || entity === void 0 ? void 0 : entity.tick$) instanceof rxjs_1.Subject;
+exports.isITickListener = isITickListener;

package/dist/base/gg-static.d.ts

@@ -0,0 +1,9 @@
+import { GgWorld } from './gg-world';
+export declare class GgStatic {
+    private static _instance;
+    static get instance(): GgStatic;
+    private constructor();
+    readonly worlds: GgWorld<any, any>[];
+    selectedWorld: GgWorld<any, any> | null;
+    console(input: string): Promise<string>;
+}

package/dist/base/gg-static.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GgStatic = void 0;
+class GgStatic {
+    constructor() {
+        this.worlds = [];
+        this.selectedWorld = null;
+        window.gg = this;
+    }
+    static get instance() {
+        if (!GgStatic._instance) {
+            GgStatic._instance = new GgStatic();
+        }
+        return GgStatic._instance;
+    }
+    console(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.selectedWorld) {
+                return 'World not selected';
+            }
+            const commands = input.split('\n');
+            let output = [];
+            for (const command of commands) {
+                const parts = command.split(' ');
+                output.push(yield this.selectedWorld.runConsoleCommand(parts.splice(0, 1)[0], parts));
+            }
+            return output.join('\n');
+        });
+    }
+}
+exports.GgStatic = GgStatic;

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

@@ -0,0 +1,14 @@
+import { Subject } from 'rxjs';
+import { BaseGgRenderer } from './entities/base-gg-renderer';
+export declare class GgViewportManager {
+    private static _instance;
+    static get instance(): GgViewportManager;
+    private constructor();
+    private readonly canvases;
+    private gameStage$;
+    protected destroyed: Subject<void>;
+    private getStageAsync;
+    createCanvas(zIndex: number): Promise<HTMLCanvasElement>;
+    registerCanvas(canvas: HTMLCanvasElement, zIndex: number): Promise<void>;
+    assignRendererToCanvas(renderer: BaseGgRenderer, canvas: HTMLCanvasElement): Promise<void>;
+}