emeraldengine 2.0.0

package/dist/types/imports/components/RigidBody.d.ts

@@ -0,0 +1,104 @@
+import * as planck from "planck";
+import { Physics, Vector2 } from "../Physics";
+import Collider from "./Collider";
+import GameObject from "./GameObject";
+/**
+ * @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
+ */
+declare class RigidBody {
+    physics: Physics;
+    offset: Vector2;
+    type: string;
+    body: planck.Body;
+    parentObject: GameObject | null;
+    position: Vector2;
+    collider: Collider | null;
+    id: string;
+    name: string;
+    constructor(physics: Physics, type: string, position: Vector2, fixedRotation: boolean, parentObject?: GameObject | null, offset?: Vector2);
+    /**
+     * @method updatePosition
+     * @description Updates the position of the rigidbody
+     * @param {Vector2} position - The new position
+     */
+    updatePosition(position: Vector2): void;
+    /**
+     * @method getOffset
+     * @description Returns the offset of the rigidbody
+     * @returns {Vector2} - The offset of the rigidbody
+     */
+    getOffset(): Vector2;
+    /**
+     * @method setCollider
+     * @description Sets the collider of the rigidbody
+     * @param {Collider} collider - The collider to set
+     */
+    setCollider(collider: Collider): void;
+    /**
+     * @method setRotation
+     * @description Sets the rotation of the rigidbody
+     * @param {number} rotation - The new rotation
+     */
+    setRotation(rotation: number): void;
+    /**
+     * @method getPosition
+     * @description Returns the position of the rigidbody
+     * @returns {Vector2} - The position of the rigidbody
+     */
+    getPosition(): Vector2;
+    /**
+     * @method getAngle
+     * @description Returns the angle of the rigidbody
+     * @returns {number} - The angle of the rigidbody
+     */
+    getAngle(): number;
+    /**
+     * @method getCollider
+     * @description Returns the collider of the rigidbody
+     * @returns {Collider} - The collider of the rigidbody
+     */
+    getCollider(): Collider | null;
+    /**
+     * @method getBody
+     * @description Returns the body of the rigidbody
+     * @returns {planck.Body} - The body of the rigidbody
+     */
+    getBody(): planck.Body;
+    /**
+     * @method getPhysics
+     * @description Returns the physics engine of the rigidbody
+     * @returns {Physics} - The physics engine of the rigidbody
+     */
+    getPhysics(): Physics;
+    /**
+     * @method destroy
+     * @description Destroys the rigidbody
+     */
+    destroy(): void;
+    /**
+     * @method detachCollider
+     * @description Detaches a collider from the rigidbody
+     * @param {Collider} collider - The collider to detach
+     */
+    detachCollider(collider: Collider): void;
+    /**
+     * @method setParent
+     * @description Sets the parent object of the rigidbody
+     * @param {GameObject} parent - The parent object to set
+     */
+    setParent(parent: GameObject): void;
+    /**
+     * @method getType
+     * @description Returns the type of the rigidbody
+     * @returns {string | "static" | "dynamic" | "kinematic"} - The type of the rigidbody
+     */
+    getType(): string;
+}
+export default RigidBody;
+//# sourceMappingURL=RigidBody.d.ts.map

package/dist/types/imports/lights/DirectionalLight.d.ts

@@ -0,0 +1,26 @@
+import Color from "../Color";
+import { Vector2 } from "../Physics";
+/**
+ * @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
+ */
+declare class DirectionalLight {
+    position: Vector2;
+    direction: Vector2;
+    color: Color;
+    intensity: number;
+    width: number;
+    constructor(position: Vector2, direction: Vector2, color: Color, intensity: number, width: number);
+    /**
+     * 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: Vector2): number;
+}
+export default DirectionalLight;
+//# sourceMappingURL=DirectionalLight.d.ts.map

package/dist/types/imports/lights/PointLight.d.ts

@@ -0,0 +1,18 @@
+import Color from "../Color";
+import { Vector2 } from "../Physics";
+/**
+ * @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
+ */
+declare class PointLight {
+    position: Vector2;
+    color: Color;
+    intensity: number;
+    radius: number;
+    constructor(position: Vector2, color: Color, intensity: number, radius: number);
+}
+export default PointLight;
+//# sourceMappingURL=PointLight.d.ts.map

package/dist/types/imports/managers/AudioManager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @class AudioManager
+ * @description Manages the audio for the game
+ */
+declare class AudioManager {
+    sounds: Map<string, {
+        audio: HTMLAudioElement;
+        id: string;
+        playPromise: Promise<void> | null;
+    }>;
+    constructor();
+    /**
+     * @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: string, name: string): boolean;
+    /**
+     * @method remove
+     * @description Removes an audio file from the manager
+     * @param {string} name - The name of the audio file
+     */
+    remove(name: string): boolean;
+    /**
+     * @method play
+     * @description Plays an audio file
+     * @param {string} name - The name of the audio file
+     */
+    play(name: string): Promise<boolean>;
+    /**
+     * @method stop
+     * @description Stops an audio file
+     * @param {string} name - The name of the audio file
+     */
+    stop(name: string): Promise<boolean>;
+    /**
+     * @method stopAll
+     * @description Stops all audio files
+     */
+    stopAll(): Promise<void>;
+    /**
+     * @method playExclusive
+     * @description Plays an audio file after stopping all other audio files
+     * @param {string} name - The name of the audio file
+     */
+    playExclusive(name: string): Promise<boolean>;
+    /**
+     * @method getSound
+     * @description Returns an audio file from the manager
+     * @param {string} name - The name of the audio file
+     */
+    getSound(name: string): {
+        audio: HTMLAudioElement;
+        id: string;
+        playPromise: Promise<void> | null;
+    } | undefined;
+}
+export default AudioManager;
+//# sourceMappingURL=AudioManager.d.ts.map

package/dist/types/imports/managers/CameraManager.d.ts

@@ -0,0 +1,35 @@
+import { Vector2 } from "../Physics";
+/**
+ * @class CameraManager
+ * @description Manages the camera for the game
+ */
+declare class CameraManager {
+    static camera: any;
+    static lastPosition: Vector2 | null;
+    /**
+     * @method setLastPosition
+     * @description Sets the last position of the camera
+     * @param {Vector2} position - The position to set
+     */
+    static setLastPosition(position: Vector2): void;
+    /**
+     * @method getLastPosition
+     * @description Returns the last position of the camera
+     * @returns {Vector2} - The last position of the camera
+     */
+    static getLastPosition(): Vector2 | null;
+    /**
+     * @method setCamera
+     * @description Sets the camera for the game
+     * @param {Camera} camera - The camera to set
+     */
+    static setCamera(camera: any): void;
+    /**
+     * @method getCamera
+     * @description Returns the camera for the game
+     * @returns {Camera} - The camera for the game
+     */
+    static getCamera(): any | null;
+}
+export default CameraManager;
+//# sourceMappingURL=CameraManager.d.ts.map

package/dist/types/imports/managers/EventManager.d.ts

@@ -0,0 +1,187 @@
+import Scene from "../Scene";
+import GameObject from "../components/GameObject";
+import Instance from "../Instance";
+/**
+ * @class EventManager
+ * @description Manages the events for the game
+ * @param {HTMLCanvasElement} canvas - The canvas element
+ * @param {Scene} scene - The scene
+ * @param {Camera} camera - The camera
+ */
+declare class EventManager {
+    scene: Scene;
+    camera: any;
+    canvas: HTMLCanvasElement;
+    keyDownListeners: Map<string, Set<Function>>;
+    keyUpListeners: Map<string, Set<Function>>;
+    clickListeners: Map<string, Set<Function>>;
+    canvasWidth: number;
+    canvasHeight: number;
+    hoverListeners: Map<string, {
+        enter: Set<Function>;
+        leave: Set<Function>;
+    }>;
+    lastHoveredObject: GameObject | null;
+    lastHoveredInstance: Instance | null;
+    pressedKeys: Map<string, boolean>;
+    mousePosition: {
+        x: number;
+        y: number;
+    };
+    isDragging: boolean;
+    dragStartX: number;
+    dragStartY: number;
+    initialCameraX: number;
+    initialCameraY: number;
+    cameraWasMoved: boolean;
+    boundHandleMouseMove: (event: MouseEvent) => void;
+    boundHandleKeyDown: (event: KeyboardEvent) => void;
+    boundHandleKeyUp: (event: KeyboardEvent) => void;
+    boundHandleClick: (event: MouseEvent) => void;
+    boundHandleMouseDown: (event: MouseEvent) => void;
+    boundHandleMouseUp: (event: MouseEvent) => void;
+    constructor(canvas: HTMLCanvasElement, scene: Scene, camera: any);
+    /**
+     * @method addKeyDown
+     * @description Adds a key down event listener
+     * @param {string} key - The key to listen for
+     * @param {function} func - The function to call when the key is pressed
+     */
+    addKeyDown(key: string, func: Function): void;
+    /**
+     * @method addKeyUp
+     * @description Adds a key up event listener
+     * @param {string} key - The key to listen for
+     * @param {function} func - The function to call when the key is released
+     */
+    addKeyUp(key: string, func: Function): void;
+    /**
+     * @method removeKeyDown
+     * @description Removes a key down event listener
+     * @param {string} key - The key to remove the listener for
+     * @param {function} func - The function to remove
+     */
+    removeKeyDown(key: string, func: Function): void;
+    /**
+     * @method removeKeyUp
+     * @description Removes a key up event listener
+     * @param {string} key - The key to remove the listener for
+     * @param {function} func - The function to remove
+     */
+    removeKeyUp(key: string, func: Function): void;
+    /**
+     * @method handleKeyDown
+     * @description Handles a key down event
+     * @param {KeyboardEvent} event - The keyboard event
+     */
+    handleKeyDown(event: KeyboardEvent): void;
+    /**
+     * @method handleKeyUp
+     * @description Handles a key up event
+     * @param {KeyboardEvent} event - The keyboard event
+     */
+    handleKeyUp(event: KeyboardEvent): void;
+    /**
+     * @method isKeyPressed
+     * @description Checks if a key is pressed
+     * @param {string} key - The key to check
+     * @returns {boolean} - True if the key is pressed
+     */
+    isKeyPressed(key: string): boolean;
+    /**
+     * @method addClickEvent
+     * @description Adds a click event listener
+     * @param {GameObject} object - The object to listen for
+     * @param {function} func - The function to call when the object is clicked
+     */
+    addClickEvent(object: GameObject, func: Function): void;
+    /**
+     * @method handleClick
+     * @description Handles a click event
+     * @param {MouseEvent} event - The mouse event
+     */
+    handleClick(event: MouseEvent): void;
+    /**
+     * @method removeClickEvent
+     * @description Removes a click event listener
+     * @param {GameObject} object - The object to remove the listener for
+     * @param {function} func - The function to remove
+     */
+    removeClickEvent(object: GameObject, func: Function): void;
+    /**
+     * @method isPointInObject
+     * @description Checks if a point is in an object
+     * @param {number} x - The x coordinate of the point
+     * @param {number} y - The y coordinate of the point
+     * @param {GameObject} object - The object to check
+     * @returns {boolean} - True if the point is in the object
+     */
+    isPointInObject(x: number, y: number, object: GameObject): boolean;
+    /**
+     * @method addHoverEvent
+     * @description Adds a hover event listener
+     * @param {GameObject} object - The object to listen for
+     * @param {function} enterFunc - The function to call when the object is hovered
+     * @param {function} leaveFunc - The function to call when the object is no longer hovered
+     */
+    addHoverEvent(object: GameObject, enterFunc: Function, leaveFunc: Function): void;
+    /**
+     * @method removeHoverEvent
+     * @description Removes a hover event listener
+     * @param {GameObject} object - The object to remove the listener for
+     * @param {function} enterFunc - The function to remove
+     * @param {function} leaveFunc - The function to remove
+     */
+    removeHoverEvent(object: GameObject, enterFunc: Function, leaveFunc: Function): void;
+    /**
+     * @method handleMouseDown
+     * @description Handles a mouse down event
+     * @param {MouseEvent} event - The mouse event
+     */
+    handleMouseDown(event: MouseEvent): void;
+    /**
+     * @method handleMouseUp
+     * @description Handles a mouse up event
+     * @param {MouseEvent} event - The mouse event
+     */
+    handleMouseUp(event: MouseEvent): void;
+    /**
+     * @method handleMouseMove
+     * @description Handles a mouse move event
+     * @param {MouseEvent} event - The mouse event
+     */
+    handleMouseMove(event: MouseEvent): void;
+    /**
+     * @method getMousePosition
+     * @description Returns the mouse position
+     * @returns {Object} - The mouse position
+     */
+    getMousePosition(): {
+        x: number;
+        y: number;
+    };
+    /**
+     * @method wasCameraMoved
+     * @description Checks if the camera was moved
+     * @returns {boolean} - True if the camera was moved
+     */
+    wasCameraMoved(): boolean;
+    /**
+     * @method resetCameraMoved
+     * @description Resets the camera moved flag
+     */
+    resetCameraMoved(): void;
+    /**
+     * @method changeScene
+     * @description Changes the scene
+     * @param {Scene} scene - The scene to change to
+     */
+    changeScene(scene: Scene): void;
+    /**
+     * @method clean
+     * @description Cleans up the event manager
+     */
+    clean(): void;
+}
+export default EventManager;
+//# sourceMappingURL=EventManager.d.ts.map

package/dist/types/imports/managers/GLManager.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @class GLManager
+ * @description Manages the WebGL context for the game
+ */
+declare class GLManager {
+    static gl: WebGL2RenderingContext | null;
+    static programInfo: any | null;
+    static canvas: HTMLCanvasElement | null;
+    /**
+     * @method setGL
+     * @description Sets the WebGL context
+     * @param {WebGLRenderingContext} gl - The WebGL context
+     */
+    static setGL(gl: WebGL2RenderingContext): void;
+    /**
+     * @method setProgramInfo
+     * @description Sets the program info
+     * @param {Object} programInfo - The program info
+     */
+    static setProgramInfo(programInfo: any): void;
+    /**
+     * @method setCanvas
+     * @description Sets the canvas
+     * @param {HTMLCanvasElement} canvas - The canvas
+     */
+    static setCanvas(canvas: HTMLCanvasElement): void;
+    /**
+     * @method getGL
+     * @description Returns the WebGL context
+     * @returns {WebGLRenderingContext} - The WebGL context
+     */
+    static getGL(): WebGL2RenderingContext | null;
+    /**
+     * @method getProgramInfo
+     * @description Returns the program info
+     * @returns {Object} - The program info
+     */
+    static getProgramInfo(): any | null;
+    /**
+     * @method getCanvas
+     * @description Returns the canvas
+     * @returns {HTMLCanvasElement} - The canvas
+     */
+    static getCanvas(): HTMLCanvasElement | null;
+}
+export default GLManager;
+//# sourceMappingURL=GLManager.d.ts.map

package/dist/types/imports/managers/IDManager.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @class IDManager
+ * @description Manages the IDs for the game
+ */
+declare class IDManager {
+    static existingIDs: Set<string>;
+    /**
+     * @method generateID
+     * @description Generates a random ID
+     * @returns {string} - The random ID
+     */
+    static generateID(): string;
+    /**
+     * @method generateUniqueID
+     * @description Generates a unique ID
+     * @returns {string} - The unique ID
+     */
+    static generateUniqueID(): string;
+}
+export default IDManager;
+//# sourceMappingURL=IDManager.d.ts.map

package/dist/types/imports/managers/SceneManager.d.ts

@@ -0,0 +1,22 @@
+import Scene from "../Scene";
+/**
+ * @class SceneManager
+ * @description Manages the scene for the game
+ */
+declare class SceneManager {
+    static scene: Scene | null;
+    /**
+     * @method setScene
+     * @description Sets the scene
+     * @param {Scene} scene - The scene to set
+     */
+    static setScene(scene: Scene): void;
+    /**
+     * @method getScene
+     * @description Returns the scene
+     * @returns {Scene} - The scene
+     */
+    static getScene(): Scene | null;
+}
+export default SceneManager;
+//# sourceMappingURL=SceneManager.d.ts.map

package/dist/types/imports/particlesystem/Particle.d.ts

@@ -0,0 +1,42 @@
+import Instance from "../Instance";
+import InstancedTexture from "../InstancedTexture";
+import { Vector2, Vector3 } from "../Physics";
+import ParticleSettings from "./ParticleSettings";
+/**
+ * @class Particle
+ * @description Represents a particle in the particle system
+ * @param {InstancedTexture} instancedTexture - The instanced texture
+ * @param {Vector3} position - The position of the particle
+ * @param {number} rotation - The rotation of the particle
+ * @param {Vector2} scale - The scale of the particle
+ * @param {ParticleSettings} settings - The settings for the particle
+ */
+declare class Particle {
+    settings: ParticleSettings;
+    lifetime: number;
+    age: number;
+    velocity: Vector2;
+    gravity: Vector2;
+    instance: Instance;
+    instancedTexture: InstancedTexture;
+    constructor(instancedTexture: InstancedTexture, position: Vector3, rotation: number, scale: Vector2, settings: ParticleSettings);
+    /**
+     * @method update
+     * @description Updates the particle
+     * @param {number} dt - The delta time
+     */
+    update(dt: number): void;
+    /**
+     * @method isAlive
+     * @description Checks if the particle is alive
+     * @returns {boolean} - True if the particle is alive
+     */
+    isAlive(): boolean;
+    /**
+     * @method destroy
+     * @description Destroys the particle
+     */
+    destroy(): void;
+}
+export default Particle;
+//# sourceMappingURL=Particle.d.ts.map

package/dist/types/imports/particlesystem/ParticleSettings.d.ts

@@ -0,0 +1,49 @@
+import { Vector2 } from "../Physics";
+interface ParticleSettingsConfig {
+    lifetime?: number;
+    velocity?: Vector2;
+    gravity?: Vector2;
+    amount?: number;
+    direction?: Vector2;
+    spread?: number;
+    emissionRate?: number;
+    frame?: number;
+    offset?: number;
+    rotation?: number;
+    scale?: Vector2;
+    animation?: any;
+}
+/**
+ * @class ParticleSettings
+ * @description Represents the settings for a particle system
+ * @param {number} lifetime - The lifetime of the particle
+ * @param {Vector2} velocity - The velocity of the particle
+ * @param {Vector2} gravity - The gravity of the particle
+ * @param {number} amount - The amount of particles
+ * @param {Vector2} direction - The direction of the particle
+ * @param {number} spread - The spread of the particle
+ * @param {number} emissionRate - The emission rate of the particle
+ * @param {number} frame - The frame of the particle
+ * @param {number} offset - The offset of the particle
+ * @param {number} rotation - The rotation of the particle
+ * @param {Vector2} scale - The scale of the particle
+ * @param {Array} animation - The animation of the particle
+ */
+declare class ParticleSettings {
+    lifetime: number;
+    velocity: Vector2;
+    gravity: Vector2;
+    amount: number;
+    direction: Vector2;
+    spread: number;
+    emissionRate: number;
+    frame?: number;
+    offset?: number;
+    rotation?: number;
+    scale?: Vector2;
+    animation?: any;
+    constructor({ lifetime, velocity, gravity, amount, direction, spread, emissionRate, // particles per second
+    frame, offset, rotation, scale, animation }?: ParticleSettingsConfig);
+}
+export default ParticleSettings;
+//# sourceMappingURL=ParticleSettings.d.ts.map

package/dist/types/imports/particlesystem/Particles.d.ts

@@ -0,0 +1,71 @@
+import GameObject from "../components/GameObject";
+import InstancedTexture from "../InstancedTexture";
+import { Vector2, Vector3 } from "../Physics";
+import Particle from "./Particle";
+import ParticleSettings from "./ParticleSettings";
+/**
+ * @class Particles
+ * @description Represents a particle system
+ * @param {string} name - The name of the particle system
+ * @param {string} texturePath - The path to the texture
+ * @param {number} frameWidth - The width of the frame
+ * @param {number} frameHeight - The height of the frame
+ * @param {number} framesPerRow - The number of frames per row
+ * @param {number} totalFrames - The total number of frames
+ * @param {number} duration - The duration of the particle system
+ * @param {ParticleSettings} settings - The settings for the particle system
+ */
+export default class Particles {
+    settings: ParticleSettings;
+    position: Vector3;
+    rotation: number;
+    scale: Vector2;
+    particles: Particle[];
+    duration: number;
+    offset: number;
+    elapsed: number;
+    active: boolean;
+    instanceCount: number;
+    emissionTimer: number;
+    emittedParticles: number;
+    stopped: boolean;
+    gameObject: GameObject;
+    instancedTexture: InstancedTexture;
+    lastEmitPosition: Vector3;
+    constructor(name: string, texturePath: string, frameWidth: number, frameHeight: number, framesPerRow: number, totalFrames: number, duration?: number, settings?: ParticleSettings | null);
+    /**
+     * @method play
+     * @description Plays the particle system
+     * @param {Vector3} newPosition - The position to play the particle system at
+     */
+    play(newPosition: Vector3): void;
+    /**
+     * @method emitParticles
+     * @description Emits particles
+     * @param {number} count - The number of particles to emit
+     * @param {Vector3} position - The position to emit the particles at
+     */
+    emitParticles(count: number, position: Vector3): void;
+    /**
+     * @method update
+     * @description Updates the particle system
+     * @param {number} deltaTime - The delta time
+     */
+    update(deltaTime: number): void;
+    /**
+     * @method stop
+     * @description Stops the particle system
+     */
+    stop(): void;
+    /**
+     * @method destroy
+     * @description Destroys the particle system
+     */
+    destroy(): void;
+    /**
+     * @method reset
+     * @description Resets the particle system
+     */
+    reset(): void;
+}
+//# sourceMappingURL=Particles.d.ts.map