emeraldengine 2.0.0

package/imports/components/RigidBody.js

@@ -0,0 +1,169 @@
+import * as planck from "planck";
+import IDManager from "../managers/IDManager.js";
+import { Vector2 } from "../Physics.js";
+import Collider from "./Collider.js";
+
+/**
+ * @class RigidBody
+ * @param {Physics} physics - The physics engine
+ * @param {string | "static" | "dynamic" | "kinematic"} type - The type of rigidbody
+ * @param {Vector2} position - The position of the rigidbody
+ * @param {boolean} fixedRotation - Whether the rigidbody is fixed rotation
+ * @param {GameObject} parentObject - The parent object of the rigidbody
+ * @param {Vector2} offset - The offset of the rigidbody
+ */
+class RigidBody {
+  constructor(
+    physics,
+    type,
+    position,
+    fixedRotation,
+    parentObject = null,
+    offset = new Vector2(0, 0)
+  ) {
+    this.physics = physics;
+    this.offset = offset;
+    this.type = type;
+    this.body = physics.world.createBody({
+      type: type,
+      position: new planck.Vec2(
+        (position.x + offset.x) / physics.scale,
+        (position.y + offset.y) / physics.scale
+      ),
+      fixedRotation: fixedRotation,
+    });
+    this.parentObject = parentObject;
+    this.position = position;
+    this.collider = null;
+    this.id = IDManager.generateUniqueID();
+    this.name = "RigidBody" + this.id;
+  }
+
+  /**
+   * @method updatePosition
+   * @description Updates the position of the rigidbody
+   * @param {Vector2} position - The new position
+   */
+  updatePosition(position) {
+    this.body.setPosition(
+      new planck.Vec2(
+        (position.x + this.offset.x) / this.physics.scale,
+        (position.y + this.offset.y) / this.physics.scale
+      )
+    );
+  }
+
+  /**
+   * @method getOffset
+   * @description Returns the offset of the rigidbody
+   * @returns {Vector2} - The offset of the rigidbody
+   */
+  getOffset() {
+    return this.offset;
+  }
+
+  /**
+   * @method setCollider
+   * @description Sets the collider of the rigidbody
+   * @param {Collider} collider - The collider to set
+   */
+  setCollider(collider) {
+    if (collider instanceof Collider) {
+      this.collider = collider;
+    }
+  }
+
+  /**
+   * @method setRotation
+   * @description Sets the rotation of the rigidbody
+   * @param {number} rotation - The new rotation
+   */
+  setRotation(rotation) {
+    this.body.setAngle(rotation);
+  }
+
+  /**
+   * @method getPosition
+   * @description Returns the position of the rigidbody
+   * @returns {Vector2} - The position of the rigidbody
+   */
+  getPosition() {
+    return this.position;
+  }
+
+  /**
+   * @method getAngle
+   * @description Returns the angle of the rigidbody
+   * @returns {number} - The angle of the rigidbody
+   */
+  getAngle() {
+    return this.body.getAngle();
+  }
+
+  /**
+   * @method getCollider
+   * @description Returns the collider of the rigidbody
+   * @returns {Collider} - The collider of the rigidbody
+   */
+  getCollider() {
+    return this.collider;
+  }
+
+  /**
+   * @method getBody
+   * @description Returns the body of the rigidbody
+   * @returns {planck.Body} - The body of the rigidbody
+   */
+  getBody() {
+    return this.body;
+  }
+
+  /**
+   * @method getPhysics
+   * @description Returns the physics engine of the rigidbody
+   * @returns {Physics} - The physics engine of the rigidbody
+   */
+  getPhysics() {
+    return this.physics;
+  }
+
+  /**
+   * @method destroy
+   * @description Destroys the rigidbody
+   */
+  destroy() {
+    this.physics.world.destroyBody(this.body);
+  }
+
+  /**
+   * @method detachCollider
+   * @description Detaches a collider from the rigidbody
+   * @param {Collider} collider - The collider to detach
+   */
+  detachCollider(collider) {
+    if (collider && collider.getCollider()) {
+      this.body.destroyFixture(collider.getCollider());
+      this.collider = null;
+    }
+  }
+
+  /**
+   * @method setParent
+   * @description Sets the parent object of the rigidbody
+   * @param {GameObject} parent - The parent object to set
+   */
+  setParent(parent) {
+    this.parentObject = parent;
+  }
+
+  /**
+   * @method getType
+   * @description Returns the type of the rigidbody
+   * @returns {string | "static" | "dynamic" | "kinematic"} - The type of the rigidbody
+   */
+  getType() {
+    return this.type;
+  }
+}
+
+export default RigidBody;

package/imports/lights/DirectionalLight.js

@@ -0,0 +1,68 @@
+import { Vector2 } from "../Physics.js";
+
+/**
+ * @class DirectionalLight
+ * @param {Vector2} position - The position of the light
+ * @param {Vector2} direction - The direction of the light
+ * @param {Color} color - The color of the light
+ * @param {number} intensity - The intensity of the light
+ * @param {number} width - The width of the light
+ */
+class DirectionalLight {
+  constructor(position, direction, color, intensity, width) {
+    this.position = position; // Vector2 - origin point of the light
+    // Normalize the direction vector
+    const length = Math.sqrt(
+      direction.x * direction.x + direction.y * direction.y
+    );
+    this.direction = new Vector2(direction.x / length, direction.y / length); // Vector2 - normalized direction vector
+    this.color = color; // Color
+    this.intensity = intensity; // Number
+    this.width = width; // Number - width of the light beam
+  }
+
+  /**
+   * Calculate the light intensity at a given point
+   * @param {Vector2} point - The point to calculate intensity for
+   * @returns {number} - Light intensity (0-1)
+   */
+  getIntensityAtPoint(point) {
+
+    // Calculate distance from light position to point
+    const dx = point.x - this.position.x;
+    const dy = point.y - this.position.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+
+    // Calculate the projection of the point onto the light direction
+    const lightDirNormalized = new Vector2(this.direction.x, this.direction.y);
+    const toPoint = new Vector2(dx, dy);
+    const projection =
+      toPoint.x * lightDirNormalized.x + toPoint.y * lightDirNormalized.y;
+
+    // If point is behind the light, no illumination
+    if (projection < 0) {
+      return 0;
+    }
+
+    // Calculate perpendicular distance from the light beam center
+    const perpDistance = Math.abs(
+      toPoint.x * lightDirNormalized.y - toPoint.y * lightDirNormalized.x
+    );
+
+    // If point is outside the light beam width, no illumination
+    if (perpDistance > this.width / 2) {
+      return 0;
+    }
+
+    // Calculate intensity based on distance within the beam
+    const widthFactor = 1 - perpDistance / (this.width / 2);
+
+    // Optional: Add distance attenuation
+    const maxDistance = 1000; // Maximum effective distance
+    const distanceFactor = Math.max(0, 1 - distance / maxDistance);
+
+    return this.intensity * widthFactor * distanceFactor;
+  }
+}
+
+export default DirectionalLight;

package/imports/lights/PointLight.js

@@ -0,0 +1,17 @@
+/**
+ * @class PointLight
+ * @param {Vector2} position - The position of the light
+ * @param {Color} color - The color of the light
+ * @param {number} intensity - The intensity of the light
+ * @param {number} radius - The radius of the light
+ */
+class PointLight {
+  constructor(position, color, intensity, radius) {
+    this.position = position; // Vector2
+    this.color = color; // Color
+    this.intensity = intensity; // Number
+    this.radius = radius; // Number
+  }
+}
+
+export default PointLight;

package/imports/managers/AudioManager.js

@@ -0,0 +1,146 @@
+/**
+ * @class AudioManager
+ * @description Manages the audio for the game
+ */
+class AudioManager {
+  constructor() {
+    this.sounds = new Map();
+  }
+
+  /**
+   * @method add
+   * @description Adds an audio file to the manager
+   * @param {string} path - The path to the audio file
+   * @param {string} name - The name of the audio file
+   */
+  add(path, name) {
+    if (!this.sounds.has(name)) {
+      const audio = new Audio(path);
+      this.sounds.set(name, {
+        audio,
+        id: Math.random().toString(36).substring(7),
+        playPromise: null,
+      });
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * @method remove
+   * @description Removes an audio file from the manager
+   * @param {string} name - The name of the audio file
+   */
+  remove(name) {
+    return this.sounds.delete(name);
+  }
+
+  /**
+   * @method play
+   * @description Plays an audio file
+   * @param {string} name - The name of the audio file
+   */
+  async play(name) {
+    const sound = this.sounds.get(name);
+    if (sound) {
+      try {
+        // Wait for any existing play promise to resolve before starting a new one
+        if (sound.playPromise) {
+          await sound.playPromise;
+        }
+
+        sound.audio.pause();
+        sound.audio.currentTime = 0;
+
+        // Store the play promise to handle future conflicts
+        sound.playPromise = sound.audio.play();
+        await sound.playPromise;
+
+        // Clear the promise once it's resolved
+        sound.playPromise = null;
+        return true;
+      } catch (error) {
+        // Handle the interrupt error gracefully
+        console.warn(`Audio play interrupted for ${name}:`, error);
+        sound.playPromise = null;
+        return false;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * @method stop
+   * @description Stops an audio file
+   * @param {string} name - The name of the audio file
+   */
+  async stop(name) {
+    const sound = this.sounds.get(name);
+    if (sound) {
+      try {
+        // Wait for any existing play promise to resolve before stopping
+        if (sound.playPromise) {
+          await sound.playPromise;
+        }
+
+        sound.audio.pause();
+        sound.audio.currentTime = 0;
+        sound.playPromise = null;
+        return true;
+      } catch (error) {
+        // Handle any errors gracefully
+        console.warn(`Audio stop interrupted for ${name}:`, error);
+        sound.audio.pause();
+        sound.audio.currentTime = 0;
+        sound.playPromise = null;
+        return false;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * @method stopAll
+   * @description Stops all audio files
+   */
+  async stopAll() {
+    const stopPromises = Array.from(this.sounds.values()).map(async (sound) => {
+      try {
+        if (sound.playPromise) {
+          await sound.playPromise;
+        }
+        sound.audio.pause();
+        sound.audio.currentTime = 0;
+        sound.playPromise = null;
+      } catch (error) {
+        console.warn("Audio stop interrupted:", error);
+        sound.audio.pause();
+        sound.audio.currentTime = 0;
+        sound.playPromise = null;
+      }
+    });
+
+    await Promise.all(stopPromises);
+  }
+
+  /**
+   * @method playExclusive
+   * @description Plays an audio file after stopping all other audio files
+   * @param {string} name - The name of the audio file
+   */
+  async playExclusive(name) {
+    await this.stopAll();
+    return this.play(name);
+  }
+
+  /**
+   * @method getSound
+   * @description Returns an audio file from the manager
+   * @param {string} name - The name of the audio file
+   */
+  getSound(name) {
+    return this.sounds.get(name);
+  }
+}
+
+export default AudioManager;

package/imports/managers/CameraManager.js

@@ -0,0 +1,60 @@
+/**
+ * @class CameraManager
+ * @description Manages the camera for the game
+ */
+class CameraManager {
+  static camera = null;
+  static lastPosition = null;
+
+  /**
+   * @method setLastPosition
+   * @description Sets the last position of the camera
+   * @param {Vector2} position - The position to set
+   */
+  static setLastPosition(position) {
+    this.lastPosition = position;
+  }
+
+  /**
+   * @method getLastPosition
+   * @description Returns the last position of the camera
+   * @returns {Vector2} - The last position of the camera
+   */
+  static getLastPosition() {
+    if (this.lastPosition) {
+      return this.lastPosition;
+    } else {
+      console.warn("Last position is not set.");
+      return null;
+    }
+  }
+
+  /**
+   * @method setCamera
+   * @description Sets the camera for the game
+   * @param {Camera} camera - The camera to set
+   */
+  static setCamera(camera) {
+    if (camera) {
+      this.camera = camera;
+    } else {
+      console.warn("Attempted to set camera to null or undefined.");
+    }
+  }
+
+  /**
+   * @method getCamera
+   * @description Returns the camera for the game
+   * @returns {Camera} - The camera for the game
+   */
+  static getCamera() {
+    if (this.camera) {
+      return this.camera;
+    } else {
+      console.warn("Camera is not set.");
+      return null;
+    }
+  }
+}
+
+export default CameraManager;