cyberia 2.8.885

package/src/client/components/cyberia-admin/RoutesCyberiaAdmin.js

@@ -0,0 +1,57 @@
+import { loggerFactory } from '../core/Logger.js';
+import { Modal } from '../core/Modal.js';
+import { s } from '../core/VanillaJs.js';
+import { getProxyPath } from '../core/Router.js';
+
+const logger = loggerFactory(import.meta);
+
+const BannerAppTemplate = html`C Y B E R I A`;
+
+// Router
+const RoutesCyberiaAdmin = () => {
+  return {
+    '/': {
+      title: 'MMORPG',
+      render: () => Modal.onHomeRouterEvent(),
+      upperCase: true,
+    },
+    '/settings': { title: 'settings', render: () => s(`.main-btn-settings`).click() },
+    '/server': { title: 'server', render: () => s(`.main-btn-server`).click() },
+    '/log-in': { title: 'log-in', render: () => s(`.main-btn-log-in`).click() },
+    '/sign-up': { title: 'sign-up', render: () => s(`.main-btn-sign-up`).click() },
+    '/log-out': {
+      title: 'log-out',
+      render: () => s(`.main-btn-log-out`).click(),
+    },
+    '/account': {
+      title: 'account',
+      render: () => s(`.main-btn-account`).click(),
+    },
+    '/chat': { title: 'Chat', render: () => s(`.main-btn-chat`).click() },
+    '/colors': { title: 'pallet-colors', render: () => s(`.main-btn-colors`).click() },
+    '/biome': { title: 'Biome Engine', render: () => s(`.main-btn-biome`).click() },
+    '/tile': { title: 'Tile Engine', render: () => s(`.main-btn-tile`).click() },
+    '/3d': { title: '3D Engine', render: () => s(`.main-btn-3d`).click() },
+    '/world': { title: 'World Engine', render: () => s(`.main-btn-world`).click() },
+    '/item': { title: 'Item Engine', render: () => s(`.main-btn-item`).click() },
+    '/cyberia-tile-management': {
+      title: 'Cyberia Tile Management',
+      render: () => s(`.main-btn-cyberia-tile-management`).click(),
+    },
+    '/blockchain': { title: 'BlockChain Engine', render: () => s(`.main-btn-blockchain`).click() },
+    '/cloud': { title: 'Cloud', render: () => s(`.main-btn-cloud`).click() },
+    '/recover': { title: 'recover', render: () => s(`.main-btn-recover`).click() },
+    '/cyberia-instance-engine': {
+      title: 'cyberia-instance-engine',
+      render: () => s(`.main-btn-cyberia-instance-engine`).click(),
+    },
+  };
+};
+
+window.Routes = RoutesCyberiaAdmin;
+
+const RouterCyberiaAdmin = () => {
+  return { Routes: RoutesCyberiaAdmin };
+};
+
+export { RoutesCyberiaAdmin, RouterCyberiaAdmin, BannerAppTemplate };

package/src/client/components/cyberia-admin/ServerCyberiaAdmin.js

@@ -0,0 +1,129 @@
+import { CyberiaWorldService } from '../../services/cyberia-world/cyberia-world.service.js';
+import { AgGrid } from '../core/AgGrid.js';
+import { BtnIcon } from '../core/BtnIcon.js';
+import { getId } from '../core/CommonJs.js';
+import { darkTheme } from '../core/Css.js';
+import { NotificationManager } from '../core/NotificationManager.js';
+import { s } from '../core/VanillaJs.js';
+import { getProxyPath } from '../core/Router.js';
+
+const ServerCyberiaAdmin = {
+  Tokens: {},
+  Render: async function (options = { idModal: '', events: {} }) {
+    const id = options?.idModal ? options.idModal : getId(this.Tokens, 'server-cyberia-');
+    this.Tokens[id] = {
+      events: {},
+    };
+    if (options && options.events)
+      for (const keyEvent of Object.keys(options.events)) this.Tokens[id].events[keyEvent] = options.events[keyEvent];
+    const gridId = `server-grid-${id}`;
+    setTimeout(async () => {
+      const resultWorldCyberias = await CyberiaWorldService.get({ id: 'all' });
+      NotificationManager.Push({
+        html: resultWorldCyberias.status,
+        status: resultWorldCyberias.status,
+      });
+      AgGrid.grids[gridId].setGridOption('rowData', resultWorldCyberias.data);
+    });
+
+    class LoadGridServerActionsRenderer {
+      eGui;
+
+      async init(params) {
+        this.eGui = document.createElement('div');
+        const { name, status, port } = params.data;
+
+        this.eGui.innerHTML = html` ${await BtnIcon.Render({
+          label: html`<i class="fas fa-play-circle"></i>`,
+          class: `btn-server-${name}-${id}`,
+        })}`;
+      }
+
+      getGui() {
+        return this.eGui;
+      }
+
+      refresh(params) {
+        return true;
+      }
+    }
+
+    class LoadGridServerNameRenderer {
+      eGui;
+
+      async init(params) {
+        this.eGui = document.createElement('div');
+        const { name, status, port } = params.data;
+
+        this.eGui.innerHTML = html`<img
+            class="inl server-icon"
+            src="${getProxyPath()}assets/ui-icons/world-default-forest-city.png"
+          />
+          ${name}`;
+
+        setTimeout(() => {});
+      }
+
+      getGui() {
+        return this.eGui;
+      }
+
+      refresh(params) {
+        return true;
+      }
+    }
+
+    class LoadGridServerStatusRenderer {
+      eGui;
+
+      async init(params) {
+        this.eGui = document.createElement('div');
+        const { name, status, port } = params.data;
+
+        this.eGui.innerHTML = html`online <span class="server-status-circle">●</span>`;
+
+        setTimeout(() => {});
+      }
+
+      getGui() {
+        return this.eGui;
+      }
+
+      refresh(params) {
+        return true;
+      }
+    }
+    return html` ${await AgGrid.Render({
+      id: gridId,
+      darkTheme,
+      // style: {
+      //   height: '200px',
+      // },
+      gridOptions: {
+        defaultColDef: {
+          editable: false,
+          minWidth: 100,
+          filter: true,
+          autoHeight: true,
+        },
+        // rowData: [],
+        columnDefs: [
+          { field: 'name', flex: 2, headerName: 'server', cellRenderer: LoadGridServerNameRenderer },
+          { field: 'status', flex: 1, headerName: 'status', cellRenderer: LoadGridServerStatusRenderer },
+          { headerName: 'play', width: 100, cellRenderer: LoadGridServerActionsRenderer },
+        ],
+        rowSelection: 'single',
+        onSelectionChanged: async (event) => {
+          const selectedRows = AgGrid.grids[gridId].getSelectedRows();
+          console.log('selectedRows', { gridId, event, selectedRows });
+          const keyEvents = Object.keys(ServerCyberiaAdmin.Tokens[id].events);
+          if (keyEvents.length > 0) {
+            for (const keyEvent of keyEvents) await ServerCyberiaAdmin.Tokens[id].events[keyEvent](selectedRows[0]);
+          }
+        },
+      },
+    })}`;
+  },
+};
+
+export { ServerCyberiaAdmin };

package/src/client/components/cyberia-admin/SettingsCyberiaAdmin.js

@@ -0,0 +1,16 @@
+import { Css } from '../core/Css.js';
+import { FullScreen } from '../core/FullScreen.js';
+import { Translate } from '../core/Translate.js';
+import { Worker } from '../core/Worker.js';
+
+const SettingsCyberiaAdmin = {
+  Render: async function () {
+    let render = await FullScreen.RenderSetting();
+    render += await Css.RenderSetting();
+    render += await Translate.RenderSetting();
+    render += await Worker.RenderSetting();
+    return render;
+  },
+};
+
+export { SettingsCyberiaAdmin };

package/src/client/components/cyberia-admin/SignUpCyberiaAdmin.js

@@ -0,0 +1,11 @@
+import { createCyberiaUser } from '../../services/cyberia-user/cyberia-user.service.js';
+import { SignUp } from '../core/SignUp.js';
+
+const SignUpCyberiaAdmin = function () {
+  SignUp.Event['SignUpCyberiaAdmin'] = async (options) => {
+    const { user } = options;
+    await createCyberiaUser({ user });
+  };
+};
+
+export { SignUpCyberiaAdmin };

package/src/client/components/cyberia-admin/SocketIoCyberiaAdmin.js

@@ -0,0 +1,53 @@
+import { Account } from '../core/Account.js';
+import { Chat } from '../core/Chat.js';
+import { s4 } from '../core/CommonJs.js';
+import { loggerFactory } from '../core/Logger.js';
+import { SocketIo } from '../core/SocketIo.js';
+import { s } from '../core/VanillaJs.js';
+import { ElementsCyberiaAdmin } from './ElementsCyberiaAdmin.js';
+
+const logger = loggerFactory(import.meta);
+
+const SocketIoCyberiaAdmin = {
+  Init: function () {
+    return new Promise((resolve) => {
+      for (const type of Object.keys(ElementsCyberiaAdmin.Data)) {
+        SocketIo.Event[type][s4()] = async (args) => {
+          args = JSON.parse(args[0]);
+          switch (type) {
+            case 'chat':
+              {
+                const idModal = 'modal-chat';
+                if (s(`.${idModal}-chat-box`)) Chat.appendChatBox({ idModal, ...args });
+              }
+              break;
+
+            default:
+              break;
+          }
+          // logger.info('ws on event', args);
+          const { id, element, status } = args;
+
+          switch (status) {
+            case 'email-confirmed':
+              const newUser = { ...ElementsCyberiaAdmin.Data.user.main.model.user, emailConfirmed: true };
+              Account.renderVerifyEmailStatus(newUser);
+              Account.triggerUpdateEvent({ user: newUser });
+              break;
+            default:
+              break;
+          }
+        };
+      }
+      SocketIo.Event.connect[s4()] = async (reason) => {
+        // ElementsCyberiaAdmin.Init({ type, id, element });
+      };
+      SocketIo.Event.disconnect[s4()] = async (reason) => {
+        // ElementsCyberiaAdmin.removeAll();
+      };
+      return resolve();
+    });
+  },
+};
+
+export { SocketIoCyberiaAdmin };

package/src/client/components/cyberia-admin/TranslateCyberiaAdmin.js

@@ -0,0 +1,7 @@
+import { Translate } from '../core/Translate.js';
+
+const TranslateCyberiaAdmin = {
+  Init: async function () {},
+};
+
+export { TranslateCyberiaAdmin };

package/src/client/components/cyberia-biome/CityCyberiaBiome.js

@@ -0,0 +1,209 @@
+import { newInstance, random, range, round10 } from '../core/CommonJs.js';
+import { BiomeCyberiaParamsScope, getCurrentTransportData } from '../cyberia-admin/BiomeCyberiaAdmin.js';
+
+const CityCyberiaBiome = {
+  id: 'city',
+  render: async function () {
+    const dim = BiomeCyberiaParamsScope.dim * BiomeCyberiaParamsScope.dimPaintByCell;
+    const buildingStyles = [
+      {
+        name: 'blue',
+        body: ['#000c2d', '#001a5e'],
+        window: ['#ccce41', '#ffff4a', '#ffff99'],
+      },
+      {
+        name: 'purple',
+        body: ['#4f004f', '#620062'],
+        window: ['#b83e0a', '#e44d0c', '#f47239'],
+      },
+    ];
+    const pavementStyle = ['#373737', '#282828', '#1d1d1d', 'black'];
+
+    const transportsTargets = [
+      {
+        path: 'interior32',
+        dim: 1,
+        type: 'width',
+      },
+    ];
+
+    const BiomeCyberiaMatrixCyberia = {
+      color: {},
+      solid: {},
+      topLevelColor: {},
+      transports: [],
+    };
+    let colorCell;
+    let defaultColor;
+    // seeds
+    range(0, dim - 1).map((y) => {
+      range(0, dim - 1).map((x) => {
+        if (
+          x % BiomeCyberiaParamsScope.dimPaintByCell === 0 &&
+          y % BiomeCyberiaParamsScope.dimPaintByCell === 0 &&
+          random(0, 700) < 10
+        ) {
+          colorCell = buildingStyles[random(0, buildingStyles.length - 1)].body[0];
+        } else {
+          const probPavement = random(0, 700);
+          if (probPavement < 10) {
+            colorCell = pavementStyle[pavementStyle.length - 1];
+          } else if (probPavement < 100) {
+            colorCell = pavementStyle[pavementStyle.length - 2];
+          } else if (probPavement < 300) {
+            colorCell = pavementStyle[pavementStyle.length - 3];
+          } else {
+            colorCell = pavementStyle[pavementStyle.length - 4];
+          }
+          if (!defaultColor) defaultColor = pavementStyle[pavementStyle.length - 4];
+        }
+        if (!BiomeCyberiaMatrixCyberia.color[y]) BiomeCyberiaMatrixCyberia.color[y] = {};
+        if (!BiomeCyberiaMatrixCyberia.solid[y]) BiomeCyberiaMatrixCyberia.solid[y] = {};
+        if (!BiomeCyberiaMatrixCyberia.topLevelColor[y]) BiomeCyberiaMatrixCyberia.topLevelColor[y] = {};
+        BiomeCyberiaMatrixCyberia.color[y][x] = `${colorCell}`;
+        BiomeCyberiaMatrixCyberia.topLevelColor[y][x] =
+          (y === 0 && x === 0) || (x === dim - 1 && y === dim - 1) ? `${defaultColor}` : '';
+        BiomeCyberiaMatrixCyberia.solid[y][x] = 0;
+      });
+    });
+    const seedMatrixCyberia = newInstance(BiomeCyberiaMatrixCyberia.color);
+    const baseCordValidator = (x, y, maxLimitX, maxLimitY) => x >= 0 && y >= 0 && x <= maxLimitX && y <= maxLimitY;
+
+    const buildLimitStorage = {};
+    Object.keys(BiomeCyberiaMatrixCyberia.color).map((y) => {
+      Object.keys(BiomeCyberiaMatrixCyberia.color[y]).map((x) => {
+        x = parseInt(x);
+        y = parseInt(y);
+        buildingStyles.map((buildStyle) => {
+          // builging
+          if (seedMatrixCyberia[y][x] === buildStyle.body[0]) {
+            // body
+            const xFactor = random(4, 8);
+            const yFactor = random(3, 10);
+            const buildLimitX = BiomeCyberiaParamsScope.dimPaintByCell * xFactor - 1;
+            const buildLimitY = BiomeCyberiaParamsScope.dimPaintByCell * yFactor - 1;
+            const topLevelColor = {
+              y: round10(buildLimitY * 0.4),
+            };
+
+            if (!buildLimitStorage[x]) buildLimitStorage[x] = {};
+            buildLimitStorage[x][y] = {
+              buildLimitX,
+              buildLimitY,
+            };
+
+            range(0, buildLimitX).map((sumX) =>
+              range(0, buildLimitY).map((sumY) => {
+                if (baseCordValidator(x + sumX, y + sumY, dim - 1, dim - 1)) {
+                  colorCell = buildStyle.body[random(0, 500) < 100 || x + sumX <= x + random(3, 7) ? 0 : 1];
+                  const topLevelColorEnabled = sumY <= topLevelColor.y;
+                  BiomeCyberiaMatrixCyberia.solid[y + sumY][x + sumX] = topLevelColorEnabled ? 0 : 1;
+                  if (topLevelColorEnabled) {
+                    BiomeCyberiaMatrixCyberia.topLevelColor[y + sumY][x + sumX] = `${colorCell}`;
+                    if (sumX === 0 && sumY === 0)
+                      BiomeCyberiaMatrixCyberia.color[y + sumY][x + sumX] = `${defaultColor}`;
+                  } else BiomeCyberiaMatrixCyberia.color[y + sumY][x + sumX] = `${colorCell}`;
+                }
+              }),
+            );
+            // window
+            range(0, buildLimitX).map((sumX) =>
+              range(0, buildLimitY).map((sumY) => {
+                if (random(0, 1) === 0) return;
+                if (
+                  baseCordValidator(x + sumX, y + sumY, dim - 1, dim - 1) &&
+                  (x + sumX) % 4 === 0 &&
+                  (y + sumY) % 4 === 0
+                ) {
+                  // single window area
+                  const xFactorWindow = random(1, 2);
+                  const yFactorWindow = random(1, 2);
+                  range(0, xFactorWindow).map((sumX0) =>
+                    range(0, yFactorWindow).map((sumY0) => {
+                      if (
+                        baseCordValidator(x + sumX + sumX0, y + sumY + sumY0, x + buildLimitX, y + buildLimitY) &&
+                        y + sumY + sumY0 < y + buildLimitY - 4 &&
+                        y + sumY + sumY0 > y
+                      ) {
+                        colorCell = buildStyle.window[random(0, 2)];
+                        const topLevelColorEnabled = sumY + sumY0 <= topLevelColor.y;
+                        if (topLevelColorEnabled) {
+                          BiomeCyberiaMatrixCyberia.topLevelColor[y + sumY + sumY0][x + sumX + sumX0] = `${colorCell}`;
+                          if (sumX0 === 0 && sumY0 === 0)
+                            BiomeCyberiaMatrixCyberia.color[y + sumY + sumY0][x + sumX + sumX0] = `${defaultColor}`;
+                        } else BiomeCyberiaMatrixCyberia.color[y + sumY + sumY0][x + sumX + sumX0] = `${colorCell}`;
+                      }
+                    }),
+                  );
+                }
+              }),
+            );
+          }
+        });
+      });
+    });
+
+    Object.keys(BiomeCyberiaMatrixCyberia.color).map((y) => {
+      Object.keys(BiomeCyberiaMatrixCyberia.color[y]).map((x) => {
+        x = parseInt(x);
+        y = parseInt(y);
+        buildingStyles.map((buildStyle) => {
+          // builging
+          if (seedMatrixCyberia[y][x] === buildStyle.body[0]) {
+            const { buildLimitX, buildLimitY } = buildLimitStorage[x][y];
+            // door
+            const dimDoor = 2;
+            const xDoorPadding = 2;
+            const xDoorCords = range(x + xDoorPadding, x + buildLimitX - xDoorPadding - dimDoor).filter(
+              (n) => n % BiomeCyberiaParamsScope.dimPaintByCell === 0,
+            );
+            const xDoor = xDoorCords[random(0, xDoorCords.length - 1)];
+            const yDoor = y + buildLimitY;
+            let validDoor = true;
+            // colorCell = 'red';
+            range(0, dimDoor).map((deltaX) =>
+              range(1, dimDoor + 1).map((deltaY) => {
+                if (
+                  !baseCordValidator(xDoor + deltaX, yDoor + deltaY, dim - 1, dim - 1) ||
+                  !baseCordValidator(xDoor + deltaX, yDoor + deltaY, x + buildLimitX, y + buildLimitY + dimDoor + 1)
+                ) {
+                  validDoor = false;
+                }
+
+                if (
+                  BiomeCyberiaMatrixCyberia.color[yDoor + deltaY] &&
+                  BiomeCyberiaMatrixCyberia.color[yDoor + deltaY][xDoor + deltaX] &&
+                  !pavementStyle.includes(BiomeCyberiaMatrixCyberia.color[yDoor + deltaY][xDoor + deltaX])
+                ) {
+                  validDoor = false;
+                }
+              }),
+            );
+            if (!validDoor) return;
+            colorCell = 'black';
+            BiomeCyberiaMatrixCyberia.transports.push({
+              x1: xDoor,
+              y1: yDoor - dimDoor,
+              ...getCurrentTransportData('city', transportsTargets),
+            });
+            range(0, dimDoor).map((deltaX) =>
+              range(0, dimDoor).map((deltaY) => {
+                if (
+                  baseCordValidator(xDoor + deltaX, yDoor - deltaY, dim - 1, dim - 1) &&
+                  baseCordValidator(xDoor + deltaX, yDoor - deltaY, x + buildLimitX, y + buildLimitY)
+                ) {
+                  BiomeCyberiaMatrixCyberia.color[yDoor - deltaY][xDoor + deltaX] = `${colorCell}`;
+                  BiomeCyberiaMatrixCyberia.solid[yDoor - deltaY][xDoor + deltaX] = 0;
+                }
+              }),
+            );
+          }
+        });
+      });
+    });
+
+    return BiomeCyberiaMatrixCyberia;
+  },
+};
+
+export { CityCyberiaBiome };