@gg-web-engine/core 0.0.24 → 0.0.28

package/dist/dev/gg-static.js

@@ -0,0 +1,141 @@
+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());
+    });
+};
+import { GgWorld } from '../base';
+import { GgConsoleUI } from './gg-console.ui';
+import { GgDebuggerUI } from './gg-debugger.ui';
+export class GgStatic {
+    constructor() {
+        this.debuggerUI = new GgDebuggerUI();
+        this.consoleUI = new GgConsoleUI();
+        this._devConsoleEnabled = false;
+        this.consoleKeyPressEventListener = (event) => {
+            if (event.code === 'Backquote') {
+                event.preventDefault();
+                if (this.consoleUI.isUIShown) {
+                    this.consoleUI.destroyUI();
+                }
+                else {
+                    this.consoleUI.createUI();
+                }
+            }
+        };
+        this._selectedWorld = null;
+        this.consoleCommands = new Map();
+        this.registerConsoleCommand(null, 'ls_commands', () => __awaiter(this, void 0, void 0, function* () {
+            return this.availableCommands
+                .map(([key, value]) => `<span style="color:yellow">${key}</span>${value.doc ? '\t<span style="color:#aaa">// ' + value.doc + '</span>' : ''}`)
+                .sort()
+                .join('\n\n');
+        }), 'no args; print all available commands');
+        this.registerConsoleCommand(null, 'ls_worlds', () => __awaiter(this, void 0, void 0, function* () {
+            return GgWorld.documentWorlds
+                .map(w => (w === this.selectedWorld ? `<span style="color:green;">* ${w.name}</span>` : `  ${w.name}`))
+                .join('\n');
+        }), 'no args; print all available worlds');
+        this.registerConsoleCommand(null, 'select_world', (...args) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            for (const w of GgWorld.documentWorlds) {
+                if (w.name === args[0]) {
+                    this._selectedWorld = w;
+                    break;
+                }
+            }
+            return ((_a = this.selectedWorld) === null || _a === void 0 ? void 0 : _a.name) || 'null';
+        }), 'args: [string]; select world by name');
+    }
+    static get instance() {
+        if (!GgStatic._instance) {
+            GgStatic._instance = new GgStatic();
+        }
+        return GgStatic._instance;
+    }
+    get devConsoleEnabled() {
+        return this._devConsoleEnabled;
+    }
+    set devConsoleEnabled(value) {
+        if (this._devConsoleEnabled === value) {
+            return;
+        }
+        this._devConsoleEnabled = value;
+        if (value) {
+            addEventListener('keypress', this.consoleKeyPressEventListener);
+        }
+        else {
+            removeEventListener('keypress', this.consoleKeyPressEventListener);
+            if (this.consoleUI.isUIShown) {
+                this.consoleUI.destroyUI();
+            }
+        }
+    }
+    get showStats() {
+        return this.debuggerUI.showStats;
+    }
+    set showStats(value) {
+        this.debuggerUI.setShowStats(this.selectedWorld, value);
+    }
+    get showDebugControls() {
+        return this.debuggerUI.showDebugControls;
+    }
+    set showDebugControls(value) {
+        this.debuggerUI.setShowDebugControls(this.selectedWorld, value);
+    }
+    get selectedWorld() {
+        return this._selectedWorld || GgWorld.documentWorlds[0] || null;
+    }
+    get availableCommands() {
+        let commands = this.consoleCommands.get(null) || {};
+        if (this.selectedWorld) {
+            commands = Object.assign(Object.assign({}, (this.consoleCommands.get(this.selectedWorld) || {})), commands);
+        }
+        return Object.entries(commands);
+    }
+    registerConsoleCommand(world, command, handler, doc) {
+        let commands = {};
+        if (!this.consoleCommands.has(world)) {
+            this.consoleCommands.set(world, commands);
+        }
+        else {
+            commands = this.consoleCommands.get(world);
+        }
+        commands[command] = { handler, doc };
+    }
+    deregisterWorldCommands(world) {
+        this.consoleCommands.delete(world);
+    }
+    console(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const commands = input.split('\n');
+            let output = [];
+            for (const command of commands) {
+                const parts = command.split(' ');
+                output.push(yield this.runConsoleCommand(parts.splice(0, 1)[0], parts));
+            }
+            return output.join('\n');
+        });
+    }
+    runConsoleCommand(command, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let action = (this.consoleCommands.get(null) || {})[command];
+            if (!action) {
+                action = (this.consoleCommands.get(this.selectedWorld) || {})[command];
+                if (!action) {
+                    return `<span style="color:red">Unrecognized command: ${command}</span>`;
+                }
+            }
+            try {
+                return yield action.handler(...args);
+            }
+            catch (err) {
+                return `<span style="color:red">${err}</span>`;
+            }
+        });
+    }
+}
+window.ggstatic = GgStatic.instance;

package/dist/dev/index.d.ts

@@ -0,0 +1,3 @@
+export * from './gg-console.ui';
+export * from './gg-debugger.ui';
+export * from './gg-static';

package/dist/dev/index.js

@@ -0,0 +1,3 @@
+export * from './gg-console.ui';
+export * from './gg-debugger.ui';
+export * from './gg-static';

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './base';
 export * from './2d';
 export * from './3d';
+export * from './dev';

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from './base';
 export * from './2d';
 export * from './3d';
+export * from './dev';

package/package.json

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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());
-    });
-};
-export 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');
-        });
-    }
-}

package/dist/base/ui/gg-debugger.ui.d.ts

@@ -1,10 +0,0 @@
-export declare class GgDebuggerUI {
-    private static _instance;
-    static get instance(): GgDebuggerUI;
-    private ui;
-    private removed$;
-    private constructor();
-    get isUIShown(): boolean;
-    createUI(): void;
-    destroyUI(): void;
-}

package/dist/base/ui/gg-debugger.ui.js

@@ -1,61 +0,0 @@
-import { GgStatic } from '../gg-static';
-import { createInlineTickController } from '../entities/controllers/inline-controller';
-import { fromEvent, Subject, takeUntil } from 'rxjs';
-import Stats from 'stats.js';
-export class GgDebuggerUI {
-    constructor() {
-        this.ui = null;
-        this.removed$ = new Subject();
-    }
-    static get instance() {
-        if (!this._instance) {
-            this._instance = new GgDebuggerUI();
-        }
-        return this._instance;
-    }
-    get isUIShown() {
-        return !!this.ui;
-    }
-    createUI() {
-        var _a;
-        const stats = new Stats();
-        stats.dom.style.left = 'unset';
-        stats.dom.style.right = '0';
-        stats.showPanel(0); // 0: fps, 1: ms, 2: mb
-        document.body.appendChild(stats.dom);
-        createInlineTickController(GgStatic.instance.selectedWorld, -1)
-            .pipe(takeUntil(this.removed$))
-            .subscribe(() => {
-            stats === null || stats === void 0 ? void 0 : stats.begin();
-        });
-        createInlineTickController(GgStatic.instance.selectedWorld, 10000)
-            .pipe(takeUntil(this.removed$))
-            .subscribe(() => {
-            stats === null || stats === void 0 ? void 0 : stats.end();
-        });
-        const customContainer = document.createElement('div');
-        customContainer.style.cssText =
-            'position:fixed;top:48px;right:0;opacity:0.9;z-index:9999;background-color:#333;color:white';
-        customContainer.innerHTML = `<input type="checkbox" name="checkbox" id="physics_debugger_checkbox_id" value="1"${((_a = GgStatic.instance.selectedWorld) === null || _a === void 0 ? void 0 : _a.physicsWorld.physicsDebugViewActive) ? ' checked' : ''}>
-                                 <label for="physics_debugger_checkbox_id" style="user-select: none;">Show physics bodies in scene</label>`;
-        document.body.appendChild(customContainer);
-        fromEvent(document.getElementById('physics_debugger_checkbox_id'), 'change')
-            .pipe(takeUntil(this.removed$))
-            .subscribe(e => {
-            GgStatic.instance.console('dr_drawphysics ' + e.target.checked).then();
-        });
-        this.ui = {
-            stats,
-            customContainer,
-        };
-    }
-    destroyUI() {
-        if (this.ui) {
-            document.body.removeChild(this.ui.stats.dom);
-            document.body.removeChild(this.ui.customContainer);
-            this.ui.stats.end();
-            this.ui = null;
-        }
-        this.removed$.next();
-    }
-}