emeraldengine 2.0.0

package/dist/types/imports/Physics.d.ts

@@ -0,0 +1,139 @@
+import * as planck from "planck";
+/**
+ * @class Physics
+ * @description Represents the physics engine
+ * @param {number} gravity - The gravity of the physics engine
+ * @param {number} scale - The scale of the physics engine
+ * @param {number} velocityThreshold - The velocity threshold of the physics engine
+ */
+declare class Physics {
+    world: planck.World;
+    gravity: number;
+    scale: number;
+    constructor(gravity: number, scale: number, velocityThreshold?: number);
+    /**
+     * @method createBody
+     * @description Creates a body in the physics engine
+     * @param {string} type - The type of the body
+     * @param {Vector2} position - The position of the body
+     * @param {boolean} fixedRotation - Whether the body should have a fixed rotation
+     * @param {boolean} attachFixture - Whether the body should have a fixture
+     * @param {Vector2} fixtureSize - The size of the fixture
+     * @param {number} density - The density of the fixture
+     * @param {number} friction - The friction of the fixture
+     * @param {number} restitution - The restitution of the fixture
+     * @returns {Body} - The body
+     */
+    createBody(type: string, position?: Vector2, fixedRotation?: boolean, attachFixture?: boolean, fixtureSize?: Vector2, density?: number, friction?: number, restitution?: number): planck.Body;
+    /**
+     * @method onCollisionEnter
+     * @description Handles the collision enter event
+     * @param {Function} callback - The callback function to handle the collision enter event
+     */
+    onCollisionEnter(callback: (bodyA: planck.Body, bodyB: planck.Body, contact: planck.Contact) => void): void;
+    /**
+     * @method onCollisionExit
+     * @description Handles the collision exit event
+     * @param {Function} callback - The callback function to handle the collision exit event
+     */
+    onCollisionExit(callback: (bodyA: planck.Body, bodyB: planck.Body, contact: planck.Contact) => void): void;
+    /**
+     * @method process
+     * @description Processes the physics engine
+     * @param {number} dt - The delta time
+     */
+    process(dt: number): void;
+    /**
+     * @method clear
+     * @description Clears the physics engine objects and resets the gravity
+     */
+    clear(): void;
+    /**
+     * @method getGravity
+     * @description Returns the gravity of the physics engine
+     * @returns {number} - The gravity of the physics engine
+     */
+    getGravity(): number;
+    /**
+     * @method getScale
+     * @description Returns the scale of the physics engine
+     * @returns {number} - The scale of the physics engine
+     */
+    getScale(): number;
+    /**
+     * @method scheduleAction
+     * @description Schedules an action to be executed as soon as possible
+     * @param {Function} callback - The callback function to execute
+     */
+    static scheduleAction(callback: () => void): void;
+}
+/**
+ * @class Vector2
+ * @description Represents a 2D vector
+ * @param {number} x - The x coordinate of the vector
+ * @param {number} y - The y coordinate of the vector
+ */
+declare class Vector2 {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    /**
+     * @method equals
+     * @description Checks if the vector is equal to another vector
+     * @param {Vector2} other - The other vector
+     * @returns {boolean} - True if the vector is equal to the other vector
+     */
+    equals(other: Vector2): boolean;
+    /**
+     * @method getX
+     * @description Returns the x coordinate of the vector
+     * @returns {number} - The x coordinate of the vector
+     */
+    getX(): number;
+    /**
+     * @method getY
+     * @description Returns the y coordinate of the vector
+     * @returns {number} - The y coordinate of the vector
+     */
+    getY(): number;
+}
+/**
+ * @class Vector3
+ * @description Represents a 3D vector
+ * @param {number} x - The x coordinate of the vector
+ * @param {number} y - The y coordinate of the vector
+ * @param {number} z - The z coordinate of the vector
+ */
+declare class Vector3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x: number, y: number, z: number);
+    /**
+     * @method equals
+     * @description Checks if the vector is equal to another vector
+     * @param {Vector3} other - The other vector
+     * @returns {boolean} - True if the vector is equal to the other vector
+     */
+    equals(other: Vector3): boolean;
+    /**
+     * @method getX
+     * @description Returns the x coordinate of the vector
+     * @returns {number} - The x coordinate of the vector
+     */
+    getX(): number;
+    /**
+     * @method getY
+     * @description Returns the y coordinate of the vector
+     * @returns {number} - The y coordinate of the vector
+     */
+    getY(): number;
+    /**
+     * @method getZ
+     * @description Returns the z coordinate of the vector
+     * @returns {number} - The z coordinate of the vector
+     */
+    getZ(): number;
+}
+export { Physics, Vector2, Vector3 };
+//# sourceMappingURL=Physics.d.ts.map

package/dist/types/imports/Scene.d.ts

@@ -0,0 +1,39 @@
+import GameObject from "./components/GameObject";
+/**
+ * @class Scene
+ * @description Represents a scene
+ * @param {Array} objects - The objects in the scene
+ */
+declare class Scene {
+    objects: GameObject[];
+    constructor(objects?: GameObject[]);
+    /**
+     * @method add
+     * @description Adds an object to the scene
+     * @param {GameObject} object - The object to add
+     */
+    add(object: GameObject): void;
+    /**
+     * @method remove
+     * @description Removes an object from the scene
+     * @param {GameObject} object - The object to remove
+     */
+    remove(object: GameObject): void;
+    /**
+     * @method setIsActive
+     * @description Sets the active state of the scene
+     * @param {boolean} bool - The active state
+     */
+    setIsActive(bool: boolean): void;
+    /**
+     * @method setActiveRecursive
+     * @description Sets the active state of the scene recursively
+     * @param {Object} object - The object to set the active state of
+     * @param {boolean} bool - The active state
+     */
+    setActiveRecursive(object: GameObject, bool: boolean): void;
+    [Symbol.iterator](): Iterator<GameObject>;
+    forEach(callback: (object: GameObject) => void): void;
+}
+export default Scene;
+//# sourceMappingURL=Scene.d.ts.map

package/dist/types/imports/Shaders.d.ts

@@ -0,0 +1,4 @@
+declare const STANDARD_VERTEX_SHADER: string;
+declare const STANDARD_FRAGMENT_SHADER: string;
+export { STANDARD_VERTEX_SHADER, STANDARD_FRAGMENT_SHADER };
+//# sourceMappingURL=Shaders.d.ts.map

package/dist/types/imports/Shapes.d.ts

@@ -0,0 +1,25 @@
+import Drawable from "./Drawable";
+/**
+ * @class Square2D
+ * @description Represents a square 2D shape
+ */
+declare class Square2D extends Drawable {
+    constructor();
+}
+/**
+ * @class Triangle2D
+ * @description Represents a triangle 2D shape
+ */
+declare class Triangle2D extends Drawable {
+    constructor();
+}
+/**
+ * @class Circle2D
+ * @description Represents a circle 2D shape
+ * @param {number} segments - The number of segments to use to draw the circle
+ */
+declare class Circle2D extends Drawable {
+    constructor(segments?: number);
+}
+export { Square2D, Triangle2D, Circle2D };
+//# sourceMappingURL=Shapes.d.ts.map

package/dist/types/imports/Storage.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @class Storage
+ * @description Manages the storage of the game
+ */
+declare class Storage {
+    /**
+     * @method writeToLocalStorage
+     * @description Writes to local storage
+     * @param {string} key - The key to write to
+     * @param {any} value - The value to write to
+     */
+    static writeToLocalStorage(key: string, value: any): void;
+    /**
+     * @method readFromLocalStorage
+     * @description Reads from local storage
+     * @param {string} key - The key to read from
+     * @returns {any} - The value read from local storage
+     */
+    static readFromLocalStorage(key: string): any;
+    /**
+     * @method clearLocalStorage
+     * @description Clears local storage
+     */
+    static clearLocalStorage(): void;
+    /**
+     * @method writeToSessionStorage
+     * @description Writes to session storage
+     * @param {string} key - The key to write to
+     * @param {any} value - The value to write to
+     */
+    static writeToSessionStorage(key: string, value: any): void;
+    /**
+     * @method readFromSessionStorage
+     * @description Reads from session storage
+     * @param {string} key - The key to read from
+     * @returns {any} - The value read from session storage
+     */
+    static readFromSessionStorage(key: string): any;
+    /**
+     * @method clearSessionStorage
+     * @description Clears session storage
+     */
+    static clearSessionStorage(): void;
+}
+export default Storage;
+//# sourceMappingURL=Storage.d.ts.map

package/dist/types/imports/Texture.d.ts

@@ -0,0 +1,19 @@
+import Drawable from "./Drawable";
+/**
+ * @class Texture
+ * @description Represents a texture component
+ * @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} animationSpeed - The speed of the animation
+ * @param {boolean} autoPlay - Whether the animation should play automatically
+ * @param {boolean} pixelart - Whether the texture is a pixel art texture
+ * @param {boolean} useLighting - Whether the texture should react to lighting
+ */
+declare class Texture extends Drawable {
+    constructor(texturePath?: string, frameWidth?: number, frameHeight?: number, framesPerRow?: number, totalFrames?: number, animationSpeed?: number, autoPlay?: boolean, pixelart?: boolean, useLighting?: boolean);
+}
+export default Texture;
+//# sourceMappingURL=Texture.d.ts.map

package/dist/types/imports/Time.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @class Time
+ * @description Represents the time
+ * @param {number} deltaTime - The delta time
+ */
+declare class Time {
+    static deltaTime: number;
+    /**
+     * @method getDeltaTime
+     * @description Returns the delta time
+     * @returns {number} - The delta time
+     */
+    static getDeltaTime(): number;
+    /**
+     * @method setDeltaTime
+     * @description Sets the delta time
+     * @param {number} deltaTime - The delta time
+     */
+    static setDeltaTime(deltaTime: number): void;
+}
+export default Time;
+//# sourceMappingURL=Time.d.ts.map

package/dist/types/imports/Transform.d.ts

@@ -0,0 +1,41 @@
+import { Vector2, Vector3 } from "./Physics";
+/**
+ * @class Transform
+ * @description Represents a transform
+ * @param {Vector3} position - The position of the transform
+ * @param {number} rotation - The rotation of the transform
+ * @param {Vector2} scale - The scale of the transform
+ */
+declare class Transform {
+    position: Vector3;
+    rotation: number;
+    scale: Vector2;
+    constructor(position: Vector3, rotation: number, scale: Vector2);
+    /**
+     * @method equals
+     * @description Checks if the transform is equal to another transform
+     * @param {Transform} other - The other transform
+     * @returns {boolean} - True if the transform is equal to the other transform
+     */
+    equals(other: Transform): boolean;
+    /**
+     * @method getPosition
+     * @description Returns the position of the transform
+     * @returns {Vector3} - The position of the transform
+     */
+    getPosition(): Vector3;
+    /**
+     * @method getRotation
+     * @description Returns the rotation of the transform
+     * @returns {number} - The rotation of the transform
+     */
+    getRotation(): number;
+    /**
+     * @method getScale
+     * @description Returns the scale of the transform
+     * @returns {Vector2} - The scale of the transform
+     */
+    getScale(): Vector2;
+}
+export default Transform;
+//# sourceMappingURL=Transform.d.ts.map

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

@@ -0,0 +1,41 @@
+import * as planck from "planck";
+import BoxColliderDebug from "./BoxColliderDebug";
+import Collider from "./Collider";
+import { Vector2 } from "../Physics";
+import RigidBody from "./RigidBody";
+import GameObject from "./GameObject";
+/**
+ * @class BoxCollider
+ * @extends Collider
+ * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
+ * @param {Vector2} fixtureSize - The size of the collider
+ * @param {number} density - The density of the collider
+ * @param {number} friction - The friction of the collider
+ * @param {number} restitution - The restitution of the collider
+ * @param {boolean} isSensor - Whether the collider is a sensor
+ * @param {GameObject} parentObject - The parent object of the collider
+ */
+declare class BoxCollider extends Collider {
+    collider: planck.Fixture;
+    fixtureSize: Vector2;
+    name: string;
+    debugShape: BoxColliderDebug;
+    constructor(rigidbody: RigidBody, fixtureSize: Vector2, density: number, friction: number, restitution: number, isSensor?: boolean, parentObject?: GameObject | null);
+    /**
+     * @method showDebugShape
+     * @description Shows the debug shape of the collider
+     */
+    showDebugShape(): void;
+    /**
+     * @method hideDebugShape
+     * @description Hides the debug shape of the collider
+     */
+    hideDebugShape(): void;
+    /**
+     * @method getFixtureSize
+     * @description Returns the size of the collider
+     */
+    getFixtureSize(): Vector2;
+}
+export default BoxCollider;
+//# sourceMappingURL=BoxCollider.d.ts.map

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

@@ -0,0 +1,19 @@
+import Color from "../Color";
+import { Physics } from "../Physics";
+import GameObject from "./GameObject";
+import RigidBody from "./RigidBody";
+/**
+ * @class BoxColliderDebug
+ * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
+ * @param {Color} color - The color of the collider
+ */
+declare class BoxColliderDebug {
+    rigidbody: RigidBody;
+    physics: Physics;
+    scale: number;
+    color: Color;
+    gameObject: GameObject;
+    constructor(rigidbody: RigidBody, color?: Color | null);
+}
+export default BoxColliderDebug;
+//# sourceMappingURL=BoxColliderDebug.d.ts.map

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

@@ -0,0 +1,39 @@
+import * as planck from "planck";
+import CircleColliderDebug from "./CircleColliderDebug";
+import Collider from "./Collider";
+import RigidBody from "./RigidBody";
+/**
+ * @class CircleCollider
+ * @extends Collider
+ * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
+ * @param {number} radius - The radius of the collider
+ * @param {number} density - The density of the collider
+ * @param {number} friction - The friction of the collider
+ * @param {number} restitution - The restitution of the collider
+ * @param {boolean} isSensor - Whether the collider is a sensor
+ * @param {GameObject} parentObject - The parent object of the collider
+ */
+declare class CircleCollider extends Collider {
+    radius: number;
+    debugShape: CircleColliderDebug;
+    collider: planck.Fixture;
+    name: string;
+    constructor(rigidbody: RigidBody, radius: number, density: number, friction: number, restitution: number, isSensor?: boolean, parentObject?: null);
+    /**
+     * @method showDebugShape
+     * @description Shows the debug shape of the collider
+     */
+    showDebugShape(): void;
+    /**
+     * @method hideDebugShape
+     * @description Hides the debug shape of the collider
+     */
+    hideDebugShape(): void;
+    /**
+     * @method getRadius
+     * @description Returns the radius of the collider
+     */
+    getRadius(): number;
+}
+export default CircleCollider;
+//# sourceMappingURL=CircleCollider.d.ts.map

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

@@ -0,0 +1,19 @@
+import Color from "../Color";
+import { Physics } from "../Physics";
+import GameObject from "./GameObject";
+import RigidBody from "./RigidBody";
+/**
+ * @class CircleColliderDebug
+ * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
+ * @param {Color} color - The color of the collider
+ */
+declare class CircleColliderDebug {
+    rigidbody: RigidBody;
+    physics: Physics;
+    scale: number;
+    color: Color;
+    gameObject: GameObject;
+    constructor(rigidbody: RigidBody, color?: Color | null);
+}
+export default CircleColliderDebug;
+//# sourceMappingURL=CircleColliderDebug.d.ts.map

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

@@ -0,0 +1,53 @@
+import { Vector2 } from "../Physics";
+import GameObject from "./GameObject";
+import RigidBody from "./RigidBody";
+import * as planck from "planck";
+/**
+ * @class Collider
+ * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
+ * @param {boolean} isSensor - Whether the collider is a sensor
+ * @param {GameObject} parentObject - The parent object of the collider
+ */
+declare class Collider {
+    rigidbody: RigidBody;
+    parentObject: GameObject | null;
+    isSensor: boolean;
+    id: string;
+    name: string;
+    collider: planck.Fixture | null;
+    fixtureSize: Vector2 | null;
+    radius: number | null;
+    constructor(rigidbody: RigidBody, isSensor?: boolean, parentObject?: GameObject | null);
+    /**
+     * @method getRigidBody
+     * @description Returns the rigidbody of the collider
+     */
+    getRigidBody(): RigidBody;
+    /**
+     * @method setParent
+     * @description Sets the parent object of the collider
+     */
+    setParent(parent: GameObject): void;
+    /**
+     * @method getCollider
+     * @description Returns the collider
+     */
+    getCollider(): planck.Fixture | null;
+    /**
+     * @method getFixtureSize
+     * @description Returns the size of the collider
+     */
+    getFixtureSize(): Vector2 | null;
+    /**
+     * @method getRadius
+     * @description Returns the radius of the collider
+     */
+    getRadius(): number | null;
+    /**
+     * @method getParent
+     * @description Returns the parent object of the collider
+     */
+    getParent(): GameObject | null;
+}
+export default Collider;
+//# sourceMappingURL=Collider.d.ts.map

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

@@ -0,0 +1,72 @@
+import { Vector2, Vector3 } from "../Physics";
+import Transform from "../Transform";
+import RigidBody from "./RigidBody";
+import { mat4 } from "gl-matrix";
+/**
+ * @class GameObject
+ * @param {string} name - The name of the game object
+ * @param {Vector3} position - The position of the game object
+ * @param {number} rotation - The rotation of the game object
+ * @param {Vector2} scale - The scale of the game object
+ */
+declare class GameObject {
+    name: string;
+    components: any[];
+    id: string;
+    isActive: boolean;
+    transform: Transform;
+    opacity: number;
+    constructor(name: string, position?: Vector3, rotation?: number, scale?: Vector2);
+    /**
+     * @method addComponent
+     * @description Adds a component to the game object
+     * @param {Component} componentInstance - The component to add
+     */
+    addComponent(componentInstance: any): void;
+    /**
+     * @method removeComponent
+     * @description Removes a component from the game object
+     * @param {Component} component - The component to remove
+     */
+    removeComponent(component: any): void;
+    /**
+     * @method setIsActive
+     * @description Sets the active state of the game object
+     * @param {boolean} bool - The active state
+     */
+    setIsActive(bool: boolean): void;
+    /**
+     * @method setOpacity
+     * @description Sets the opacity of the game object (0..1)
+     * @param {number} value - The opacity value between 0 and 1
+     */
+    setOpacity(value: number): void;
+    /**
+     * @method getOpacity
+     * @description Gets the opacity of the game object
+     * @returns {number} - The opacity value between 0 and 1
+     */
+    getOpacity(): number;
+    /**
+     * @method getComponent
+     * @description Returns a component from the game object
+     * @param {Component} componentType - The type of component to return
+     */
+    getComponent(componentType: any): any;
+    /**
+     * @method getRigidBodyAtPosition
+     * @description Returns the rigidbody at a position
+     * @param {Vector2} position - The position to check
+     */
+    getRigidBodyAtPosition(position: Vector2): RigidBody | null;
+    /**
+     * @method draw
+     * @description Draws the game object
+     * @param {Matrix4} globalViewMatrix - The global view matrix
+     * @param {WebGLUniformLocation} uniformLocation - The uniform location
+     * @param {number} currentTime - The current time
+     */
+    draw(globalViewMatrix: mat4, uniformLocation: WebGLUniformLocation, currentTime: number): void;
+}
+export default GameObject;
+//# sourceMappingURL=GameObject.d.ts.map