@cjcoding-git/gamelib 1.1.2 → 1.1.3

package/src/Core/InputManager.js

@@ -0,0 +1,195 @@
+import { GameLibCore } from "./index.js"
+class InputManager {
+  constructor() {
+    if (GameLibCore.InputManager._instance) {
+      return GameLibCore.InputManager._instance;
+    } else {
+      console.log("[GameLib] No InputManager instance found. Creating new instance...");
+      this._keys = [];
+      this._keyBinds = {};
+      this._keyBindCallbacks = {};
+      this._active = false;
+      this._mouseX = -1;
+      this._mouseY = -1;
+      this._mouseListeners = [];
+      this.bindEvents();
+      GameLibCore.InputManager._instance = this;
+    }
+  }
+  static KEYS = {
+    'ESCAPE': 27,
+    'BACKTICK': 192,
+    'ONE': 49,
+    'TWO': 50,
+    'THREE': 51,
+    'FOUR': 52,
+    'FIVE': 53,
+    'SIX': 54,
+    'SEVEN': 55,
+    'EIGHT': 56,
+    'NINE': 57,
+    'ZERO': 48,
+    'MINUS': 189,
+    'EQUALS': 187,
+    'TAB': 9,
+    'LEFTBRACKET': 219,
+    'RIGHTBRACKET': 221,
+    'BACKSLASH': 220,
+    'META': 91,
+    'SEMICOLON': 186,
+    'APOSTROPE': 222,
+    'ENTER': 13,
+    'SHIFT': 16,
+    'COMMA': 188,
+    'PERIOD': 190,
+    'SLASH': 191,
+    'CONTROL': 17,
+    'ALT': 18,
+    'UP': 38,
+    'DOWN': 40,
+    'LEFT': 37,
+    'RIGHT': 39,
+    'SPACE': 32,
+    'A': 65,
+    'B': 66,
+    'C': 67,
+    'D': 68,
+    'E': 69,
+    'F': 70,
+    'G': 71,
+    'H': 72,
+    'I': 73,
+    'J': 74,
+    'K': 75,
+    'L': 76,
+    'M': 77,
+    'N': 78,
+    'O': 79,
+    'P': 80,
+    'Q': 81,
+    'R': 82,
+    'S': 83,
+    'W': 87,
+    'X': 88,
+    'Y': 89,
+    'Z': 90
+  };
+  get keys() {
+    return this._keys;
+  }
+  setActive(active) {
+    this._active = active;
+  }
+  clearKeys() {
+    this._keys = [];
+  }
+  keyUp(evt) {
+    if (!this._active) {
+      return;
+    }
+    this._keys = this._keys.filter(key => key != evt.keyCode);
+    this._triggerKeyBind(evt.keyCode, 'up');
+  }
+  keyDown(evt) {
+    if (!this._active) {
+      return;
+    }
+    if (this._keys.indexOf(evt.keyCode) == -1) {
+      this._keys.push(evt.keyCode);
+    }
+    this._triggerKeyBind(evt.keyCode, 'down');
+  }
+  _fireMouseListener(type) {
+    for (var i = 0; i < this._mouseListeners.length; i++) {
+      var listener = this._mouseListeners[i];
+      if (listener.type === type) {
+        if (listener.callback && typeof listener.callback === "function") {
+          listener.callback();
+        }
+      }
+    }
+  }
+  mouseMove(evt) {
+    this._mouseX = evt.clientX;
+    this._mouseY = evt.clientY;
+    this._fireMouseListener('move');
+  }
+  mouseDown(evt) {
+    this._mouseX = evt.clientX;
+    this._mouseY = evt.clientY;
+    this._fireMouseListener('down');
+  }
+  mouseUp(evt) {
+    this._mouseX = evt.clientX;
+    this._mouseY = evt.clientY;
+    this._fireMouseListener('up');
+  }
+  click(evt) {
+    this._mouseX = evt.clientX;
+    this._mouseY = evt.clientY;
+    this._fireMouseListener('click');
+  }
+  getMousePos() {
+    return [this._mouseX, this._mouseY];
+  }
+  getCanvasMousePos(canvas) {
+    var boundingRect = canvas.getBoundingClientRect();
+    return [this._mouseX - boundingRect.x, this._mouseY - boundingRect.y];
+  }
+  _callBind(keyBindName) {
+    if (this._keyBindCallbacks[keyBindName]) {
+      for (var i = 0; i < this._keyBindCallbacks[keyBindName].length; i++) {
+        var bindCallback = this._keyBindCallbacks[keyBindName][i];
+        if (bindCallback && typeof bindCallback === "function") bindCallback();
+      }
+    }
+  }
+  _triggerKeyBind(key, type) {
+    if (this._keyBinds[key]) {
+      for (var i = 0; i < this._keyBinds.length; i++) {
+        var keyBind = this._keyBinds[i];
+        if (keyBind.type === type) {
+          this.__callBind(this._keyBinds[i].name);
+        }
+      }
+    }
+  }
+  isKeyDown(key) {
+    return (this._keys.indexOf(key) != -1);
+  }
+  bindKey(key, type, name) {
+    if (!this._keyBinds[key]) this._keyBinds[key] = [];
+    this._keyBinds[key].push({
+      name: name,
+      type: type
+    });
+  }
+  registerKeyBindCallback(name, callback) {
+    if (!this._keyBindCallbacks[name]) this._keyBindCallbacks[name] = [];
+    this._keyBindCallbacks[name].push({ callback: callback });
+  }
+  static isKeyDown(key) {
+    if (GameLibCore.InputManager._instance != null) {
+      return (GameLibCore.InputManager._instance._keys.indexOf(key) != -1);
+    } else {
+      throw new GameLibCore.Error("An InputManager instance must exist to use GameLibCore.InputManager.isKeyDown(key)!");
+    }
+  }
+  addMouseListener(type, callback) {
+    this._mouseListeners.push({
+      type: type,
+      callback: callback
+    });
+  }
+  bindEvents() {
+    window.addEventListener('keyup', this.keyUp.bind(this), false);
+    window.addEventListener('keydown', this.keyDown.bind(this), false);
+    window.addEventListener('mousemove', this.mouseMove.bind(this), false);
+    window.addEventListener('mousedown', this.mouseDown.bind(this), false);
+    window.addEventListener('mouseup', this.mouseUp.bind(this), false);
+    window.addEventListener('click', this.click.bind(this), false);
+  }
+}
+export {
+  InputManager
+}

package/src/Core/Loading.js

@@ -0,0 +1,111 @@
+import { GameLibCore } from "./index.js"
+class Loading {
+  constructor() {
+    throw new GameLibCore.Error("Class Loading may not be constructed!");
+  }
+  static DEFAULT_CONFIG = {
+    background: "#10131c",
+    logo: null,
+    status: "Loading…",
+    progress: null,
+    textColor: "#ffffff",
+    mutedTextColor: "#aab3c5",
+    progressTrackColor: "#343b4d",
+    progressColor: "#78e0a3",
+    accentColor: "#78e0a3",
+    font: "16px sans-serif",
+    title: "LOADING",
+    titleFont: "bold 36px sans-serif",
+    progressWidth: 280,
+    progressHeight: 12,
+    logoWidth: 96,
+    logoHeight: 96,
+    padding: 24
+  };
+  static render(canvas, ctx, config = {}) {
+    if (!canvas || !ctx) {
+      return;
+    }
+    var options = { ...Loading.DEFAULT_CONFIG, ...(config || {}) };
+    var width = canvas.width;
+    var height = canvas.height;
+    var centerX = width / 2;
+    var centerY = height / 2;
+    var progressHeight = Math.max(1, options.progressHeight);
+    var percentageWidth = Number.isFinite(options.progress) ? 42 : 0;
+    var percentageGap = percentageWidth > 0 ? 12 : 0;
+    var maxBarWidth = Math.max(0, width - options.padding * 2 - percentageWidth - percentageGap);
+    var progressWidth = Math.min(Math.max(0, options.progressWidth), maxBarWidth);
+    var groupWidth = progressWidth + percentageGap + percentageWidth;
+    var barX = centerX - progressWidth / 2;
+    var progressY = centerY + 36;
+    var radius = progressHeight / 2;
+    ctx.save();
+    ctx.fillStyle = options.background || Loading.DEFAULT_CONFIG.background;
+    ctx.fillRect(0, 0, width, height);
+    if (options.backgroundImage && options.backgroundImage.complete !== false) {
+      ctx.save();
+      ctx.globalAlpha = options.backgroundImageOpacity == null ? 1 : options.backgroundImageOpacity;
+      ctx.drawImage(options.backgroundImage, 0, 0, width, height);
+      ctx.restore();
+    }
+    var titleY = centerY - 30;
+    if (options.logo && options.logo.complete !== false) {
+      var logoWidth = Math.min(options.logoWidth, Math.max(0, width - options.padding * 2));
+      var logoHeight = Math.min(options.logoHeight, Math.max(0, height - options.padding * 2));
+      ctx.drawImage(options.logo, centerX - logoWidth / 2, centerY - 112, logoWidth, logoHeight);
+      titleY = centerY + 10;
+    }
+    if (options.title) {
+      ctx.fillStyle = options.textColor;
+      ctx.font = options.titleFont;
+      ctx.textAlign = "center";
+      ctx.textBaseline = "middle";
+      ctx.fillText(options.title, centerX, titleY);
+    }
+    ctx.fillStyle = options.progressTrackColor;
+    ctx.beginPath();
+    ctx.roundRect(barX, progressY, progressWidth, progressHeight, radius);
+    ctx.fill();
+    if (Number.isFinite(options.progress)) {
+      var progress = Math.min(1, Math.max(0, options.progress));
+      var fillWidth = progressWidth * progress;
+      if (fillWidth > 0) {
+        ctx.fillStyle = options.progressColor;
+        ctx.beginPath();
+        ctx.roundRect(barX, progressY, fillWidth, progressHeight, Math.min(radius, fillWidth / 2));
+        ctx.fill();
+      }
+      ctx.fillStyle = options.mutedTextColor;
+      ctx.font = "12px sans-serif";
+      ctx.textAlign = "left";
+      ctx.textBaseline = "middle";
+      ctx.fillText(`${Math.round(progress * 100)}%`, barX + progressWidth + percentageGap, progressY + progressHeight / 2);
+    } else {
+      var segmentWidth = Math.max(24, progressWidth * 0.28);
+      var travel = progressWidth + segmentWidth;
+      var offset = (Date.now() / 8) % travel;
+      var segmentX = barX + offset - segmentWidth;
+      ctx.save();
+      ctx.beginPath();
+      ctx.roundRect(barX, progressY, progressWidth, progressHeight, radius);
+      ctx.clip();
+      ctx.fillStyle = options.progressColor;
+      ctx.beginPath();
+      ctx.roundRect(segmentX, progressY, segmentWidth, progressHeight, radius);
+      ctx.fill();
+      ctx.restore();
+    }
+    if (options.status) {
+      ctx.fillStyle = options.mutedTextColor;
+      ctx.font = options.font;
+      ctx.textAlign = "center";
+      ctx.textBaseline = "top";
+      ctx.fillText(options.status, centerX, progressY + progressHeight + 14);
+    }
+    ctx.restore();
+  }
+}
+export {
+  Loading
+}

package/src/Core/Matrix/index.js

@@ -0,0 +1,11 @@
+import { mat4 } from "./mat4.js"
+import { GameLibError } from "../Error.js"
+class Matrix {
+  constructor() {
+    throw new GameLibError("Class Matrix may not be constructed!");
+  }
+  static mat4 = mat4;
+}
+export {
+  Matrix
+}

package/src/Core/Matrix/mat4.js

@@ -0,0 +1,178 @@
+import { GameLibError } from "../Error.js";
+class mat4 {
+  varructor() {
+    throw new GameLibError("Class mat4 may not be varructed!");
+  }
+  static EPSILON = 1e-6;
+  static blank() {
+    return new Float32Array(16);
+  }
+  static create(out = mat4.blank()) {
+    out[0] = 1; out[1] = 0; out[2] = 0; out[3] = 0;
+    out[4] = 0; out[5] = 1; out[6] = 0; out[7] = 0;
+    out[8] = 0; out[9] = 0; out[10] = 1; out[11] = 0;
+    out[12] = 0; out[13] = 0; out[14] = 0; out[15] = 1;
+    return out;
+  }
+  static multiply(out, a, b) {
+    var aCopy = Array.from(a);
+    var bCopy = Array.from(b);
+    for(var col = 0; col < 4; col++) {
+      for (var row = 0; row < 4; row++) {
+        var sum = 0;
+        for (var k = 0; k < 4; k++) {
+          sum += aCopy[k * 4 + row] * bCopy[col * 4 + k];
+        }
+        out[col * 4 + row] = sum;
+      }
+    }
+    return out;
+  }
+  static translate(out, a, v) {
+    var x = v[0], y = v[1], z = v[2];
+    if (out !== a) {
+      for (var i = 0; i < 12; i++) out[i] = a[i];
+    }
+    out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];
+    out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];
+    out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];
+    out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];
+    return out;
+  }
+  static rotateX(out, a, rad) {
+    var s = Math.sin(rad);
+    var c = Math.cos(rad);
+    var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+    var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+    if (out !== a) {
+      out[0] = a[0]; out[1] = a[1]; out[2] = a[2]; out[3] = a[3];
+      out[12] = a[12]; out[13] = a[13]; out[14] = a[14]; out[15] = a[15];
+    }
+    out[4] = a10 * c + a20 * s;
+    out[5] = a11 * c + a21 * s;
+    out[6] = a12 * c + a22 * s;
+    out[7] = a13 * c + a23 * s;
+    out[8] = a20 * c - a10 * s;
+    out[9] = a21 * c - a11 * s;
+    out[10] = a22 * c - a12 * s;
+    out[11] = a23 * c - a13 * s;
+    return out;
+  }
+  static rotateY(out, a, rad) {
+    var s = Math.sin(rad);
+    var c = Math.cos(rad);
+    var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+    var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+    if (out !== a) {
+      out[4] = a[4]; out[5] = a[5]; out[6] = a[6]; out[7] = a[7];
+      out[12] = a[12]; out[13] = a[13]; out[14] = a[14]; out[15] = a[15];
+    }
+    out[0] = a00 * c - a20 * s;
+    out[1] = a01 * c - a21 * s;
+    out[2] = a02 * c - a22 * s;
+    out[3] = a03 * c - a23 * s;
+    out[8] = a00 * s + a20 * c;
+    out[9] = a01 * s + a21 * c;
+    out[10] = a02 * s + a22 * c;
+    out[11] = a03 * s + a23 * c;
+    return out;
+  }
+  static rotateZ(out, a, rad) {
+    var s = Math.sin(rad);
+    var c = Math.cos(rad);
+    var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+    var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+    if (out !== a) {
+      out[8] = a[8]; out[9] = a[9]; out[10] = a[10]; out[11] = a[11];
+      out[12] = a[12]; out[13] = a[13]; out[14] = a[14]; out[15] = a[15];
+    }
+    out[0] = a00 * c + a10 * s;
+    out[1] = a01 * c + a11 * s;
+    out[2] = a02 * c + a12 * s;
+    out[3] = a03 * c + a13 * s;
+    out[4] = a10 * c - a00 * s;
+    out[5] = a11 * c - a01 * s;
+    out[6] = a12 * c - a02 * s;
+    out[7] = a13 * c - a03 * s;
+    return out;
+  }
+  static scale(out, a, v) {
+    var x = v[0], y = v[1], z = v[2];
+    out[0] = a[0] * x; out[1] = a[1] * x;
+    out[2] = a[2] * x; out[3] = a[3] * x;
+    out[4] = a[4] * y; out[5] = a[5] * y;
+    out[6] = a[6] * y; out[7] = a[7] * y;
+    out[8] = a[8] * z; out[9] = a[9] * z;
+    out[10] = a[10] * z; out[11] = a[11] * z;
+    out[12] = a[12]; out[13] = a[13];
+    out[14] = a[14]; out[15] = a[15];
+    return out;
+  }
+  static transpose(out, a) {
+    var values = Array.from(a);
+    for (var col = 0; col < 4; col++) {
+      for (var row = 0; row < 4; row++) {
+        out[col * 4 + row] = values[row * 4 + col];
+      }
+    }
+    return out;
+  }
+  static invert(out, a) {
+    var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+    var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+    var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+    var a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+    var b00 = a00 * a11 - a01 * a10;
+    var b01 = a00 * a12 - a02 * a10;
+    var b02 = a00 * a13 - a03 * a10;
+    var b03 = a01 * a12 - a02 * a11;
+    var b04 = a01 * a13 - a03 * a11;
+    var b05 = a02 * a13 - a03 * a12;
+    var b06 = a20 * a31 - a21 * a30;
+    var b07 = a20 * a32 - a22 * a30;
+    var b08 = a20 * a33 - a23 * a30;
+    var b09 = a21 * a32 - a22 * a31;
+    var b10 = a21 * a33 - a23 * a31;
+    var b11 = a22 * a33 - a23 * a32;
+    var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    if (det === 0) return null;
+    det = 1 / det;
+    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+    out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+    out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+    out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+    out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+    out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+    out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+    out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+    out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+    out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+    out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+    out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+    out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+    out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+    out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+    out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+    return out;
+  }
+  static perspective(out, fovy, aspect, near, far) {
+    var f = 1 / Math.tan(fovy / 2);
+    out[0] = f / aspect;
+    out[1] = 0; out[2] = 0; out[3] = 0;
+    out[4] = 0; out[5] = f; out[6] = 0; out[7] = 0;
+    out[8] = 0; out[9] = 0; out[11] = -1;
+    out[12] = 0; out[13] = 0; out[15] = 0;
+    if (far == null || far === Infinity) {
+      out[10] = -1;
+      out[14] = -2 * near;
+    } else {
+      var nf = 1 / (near - far);
+      out[10] = (far + near) * nf;
+      out[14] = 2 * far * near * nf;
+    }
+    return out;
+  }
+}
+export {
+  mat4
+};

package/src/Core/Multiplayer.js

@@ -0,0 +1,54 @@
+import { PeerNetwork } from "./Network/PeerNetwork.js"
+class Multiplayer {
+  constructor(options = {}) {
+    this.network = new PeerNetwork(options);
+  }
+  getPeerId() {
+    return this.network.id;
+  }
+  getConnectedIds() {
+    return this.network.getConnectedIds();
+  }
+  bindDataCallback(callback) {
+    this.network.off("data", this._dataListener);
+    this._dataListener = (data, connection) => callback(data, connection);
+    this.network.on("data", this._dataListener);
+    return this;
+  }
+  setConnectPeerCallback(callback) {
+    this.network.off("connection", this._connectListener);
+    this._connectListener = (connection) => callback(connection);
+    this.network.on("connection", this._connectListener);
+    return this;
+  }
+  setPeerCloseCallback(callback) {
+    this.network.off("connectionclose", this._closeListener);
+    this._closeListener = (connection) => callback(connection);
+    this.network.on("connectionclose", this._closeListener);
+    return this;
+  }
+  createPeer(peerOptions = {}) {
+    this.network.options = Object.assign({}, this.network.options, peerOptions);
+    return this.network.start();
+  }
+  connectPeer(peerId, peerOptions = {}) {
+    this.network.options = Object.assign({}, this.network.options, peerOptions);
+    return this.network.connect(peerId);
+  }
+  sendToAll(data) {
+    return this.network.broadcast(data);
+  }
+  sendToPeer(data, peerId) {
+    return peerId == null ? this.network.broadcast(data) : this.network.send(peerId, data);
+  }
+  closePeer(peerId) {
+    return this.network.close(peerId);
+  }
+  isPeerDisconnected() {
+    return this.network.state !== "ready";
+  }
+  destroy() {
+    return this.network.destroy();
+  }
+}
+export { Multiplayer }