emeraldengine 2.2.0 → 3.0.0

package/dist/types/index.d.ts

@@ -1,32 +1,72 @@
-import Emerald from "./Emerald";
-import BitmapText from "./BitmapText";
-import Color from "./Color";
-import Drawable from "./Drawable";
-import FPSCounter from "./FPSCounter";
-import Instance from "./Instance";
-import InstancedTexture from "./InstancedTexture";
-import { Physics, Vector2, Vector3 } from "./Physics";
-import Scene from "./Scene";
-import { Square2D, Triangle2D, Circle2D } from "./Shapes";
-import Storage from "./Storage";
-import Texture from "./Texture";
-import Time from "./Time";
-import Transform from "./Transform";
-import Particle from "./particlesystem/Particle";
-import Particles from "./particlesystem/Particles";
-import ParticleSettings from "./particlesystem/ParticleSettings";
-import AudioManager from "./managers/AudioManager";
-import CameraManager from "./managers/CameraManager";
-import EventManager from "./managers/EventManager";
-import SceneManager from "./managers/SceneManager";
-import DirectionalLight from "./lights/DirectionalLight";
-import PointLight from "./lights/PointLight";
-import BoxCollider from "./components/BoxCollider";
-import BoxColliderDebug from "./components/BoxColliderDebug";
-import CircleCollider from "./components/CircleCollider";
-import CircleColliderDebug from "./components/CircleColliderDebug";
-import Collider from "./components/Collider";
-import GameObject from "./components/GameObject";
-import RigidBody from "./components/RigidBody";
-export { Emerald, BitmapText, Color, Drawable, FPSCounter, Instance, InstancedTexture, Physics, Vector2, Vector3, Scene, Square2D, Triangle2D, Circle2D, Storage, Texture, Time, Transform, Particle, Particles, ParticleSettings, AudioManager, CameraManager, EventManager, SceneManager, DirectionalLight, PointLight, BoxCollider, BoxColliderDebug, CircleCollider, CircleColliderDebug, Collider, GameObject, RigidBody, };
-//# sourceMappingURL=index.d.ts.map
+import Emerald from "./src/Emerald.js";
+import BitmapText from "./src/BitmapText.js";
+import Color from "./src/Color.js";
+import Drawable from "./src/Drawable.js";
+import FPSCounter from "./src/FPSCounter.js";
+import Instance from "./src/Instance.js";
+import InstancedTexture from "./src/InstancedTexture.js";
+import { Physics } from "./src/Physics.js";
+import { Vector2 } from "./src/Physics.js";
+import { Vector3 } from "./src/Physics.js";
+import Scene from "./src/Scene.js";
+import { Square2D } from "./src/Shapes.js";
+import { Triangle2D } from "./src/Shapes.js";
+import { Circle2D } from "./src/Shapes.js";
+import Storage from "./src/Storage.js";
+import EmeraldDB from "./src/EmeraldDB.js";
+import Texture from "./src/Texture.js";
+import Time from "./src/Time.js";
+import Transform from "./src/Transform.js";
+import MathUtils from "./src/MathUtils.js";
+import Pool from "./src/Pool.js";
+import Animator from "./src/Animator.js";
+import Tilemap from "./src/Tilemap.js";
+import CameraController from "./src/CameraController.js";
+import Camera from "./src/Camera.js";
+import Easing from "./src/Easing.js";
+import Tween from "./src/Tween.js";
+import Timer from "./src/Timer.js";
+import StateMachine from "./src/StateMachine.js";
+import SpatialGrid from "./src/SpatialGrid.js";
+import TextureAtlas from "./src/TextureAtlas.js";
+import CanvasText from "./src/CanvasText.js";
+import DebugOverlay from "./src/DebugOverlay.js";
+import Serializer from "./src/Serializer.js";
+import Coroutine from "./src/Coroutine.js";
+import Interpolator from "./src/Interpolator.js";
+import ScreenEffects from "./src/ScreenEffects.js";
+import SpriteBatch from "./src/SpriteBatch.js";
+import ParticleEmitter from "./src/ParticleEmitter.js";
+import CollisionLayers from "./src/CollisionLayers.js";
+import TiledMap from "./src/importers/TiledMap.js";
+import Aseprite from "./src/importers/Aseprite.js";
+import RenderTarget from "./src/RenderTarget.js";
+import RenderStats from "./src/managers/RenderStats.js";
+import PostProcessor from "./src/PostProcessor.js";
+import { PostEffect } from "./src/PostProcessor.js";
+import PostEffects from "./src/PostEffects.js";
+import { BloomEffect } from "./src/PostEffects.js";
+import Material from "./src/Material.js";
+import UI from "./src/UI.js";
+import InputManager from "./src/managers/InputManager.js";
+import Particle from "./src/particlesystem/Particle.js";
+import Particles from "./src/particlesystem/Particles.js";
+import ParticleSettings from "./src/particlesystem/ParticleSettings.js";
+import AudioManager from "./src/managers/AudioManager.js";
+import CameraManager from "./src/managers/CameraManager.js";
+import EventManager from "./src/managers/EventManager.js";
+import SceneManager from "./src/managers/SceneManager.js";
+import TextureManager from "./src/managers/TextureManager.js";
+import AssetManager from "./src/managers/AssetManager.js";
+import NetworkManager from "./src/managers/NetworkManager.js";
+import DirectionalLight from "./src/lights/DirectionalLight.js";
+import PointLight from "./src/lights/PointLight.js";
+import BoxCollider from "./src/components/BoxCollider.js";
+import BoxColliderDebug from "./src/components/BoxColliderDebug.js";
+import CircleCollider from "./src/components/CircleCollider.js";
+import CircleColliderDebug from "./src/components/CircleColliderDebug.js";
+import Collider from "./src/components/Collider.js";
+import GameObject from "./src/components/GameObject.js";
+import RigidBody from "./src/components/RigidBody.js";
+import Behaviour from "./src/components/Behaviour.js";
+export { Emerald, BitmapText, Color, Drawable, FPSCounter, Instance, InstancedTexture, Physics, Vector2, Vector3, Scene, Square2D, Triangle2D, Circle2D, Storage, EmeraldDB, Texture, Time, Transform, MathUtils, Pool, Animator, Tilemap, CameraController, Camera, Easing, Tween, Timer, StateMachine, SpatialGrid, TextureAtlas, CanvasText, DebugOverlay, Serializer, Coroutine, Interpolator, ScreenEffects, SpriteBatch, ParticleEmitter, CollisionLayers, TiledMap, Aseprite, RenderTarget, RenderStats, PostProcessor, PostEffect, PostEffects, BloomEffect, Material, UI, InputManager, Particle, Particles, ParticleSettings, AudioManager, CameraManager, EventManager, SceneManager, TextureManager, AssetManager, NetworkManager, DirectionalLight, PointLight, BoxCollider, BoxColliderDebug, CircleCollider, CircleColliderDebug, Collider, GameObject, RigidBody, Behaviour };

package/dist/types/src/Animator.d.ts

@@ -0,0 +1,50 @@
+export default Animator;
+/**
+ * @class Animator
+ * @description A component that manages named animation clips for a Texture (or
+ * any Drawable) on the same GameObject. Register clips once, then switch between
+ * them by name — handy for character states like idle/run/jump.
+ *
+ * @example
+ * const anim = new Animator();
+ * anim.addClip("idle", [0, 1, 2, 3], { speed: 150 });
+ * anim.addClip("jump", [8, 9], { speed: 100, loop: false });
+ * obj.addComponent(texture);
+ * obj.addComponent(anim);
+ * anim.play("idle");
+ */
+declare class Animator extends Behaviour {
+    clips: Map<any, any>;
+    current: any;
+    drawable: any;
+    /**
+     * @method addClip
+     * @description Registers a named clip.
+     * @param {string} name - The clip name
+     * @param {number[]} frames - Frame indices to play
+     * @param {Object} [options] - { speed = 100, loop = true }
+     * @returns {Animator} - this
+     */
+    addClip(name: string, frames: number[], options?: any): Animator;
+    /** @private */
+    private _resolveDrawable;
+    /**
+     * @method play
+     * @description Plays a registered clip. No-op if it's already current.
+     * @param {string} name - The clip name
+     * @returns {Animator} - this
+     */
+    play(name: string): Animator;
+    /**
+     * @method stop
+     * @description Stops the current animation.
+     */
+    stop(): void;
+    /**
+     * @method getCurrent
+     * @description Returns the name of the currently playing clip (or null).
+     * @returns {string|null}
+     */
+    getCurrent(): string | null;
+}
+import Behaviour from "./components/Behaviour.js";

package/dist/types/{BitmapText.d.ts → src/BitmapText.d.ts}

@@ -1,7 +1,4 @@
-import Color from "./Color";
-import GameObject from "./components/GameObject";
-import InstancedTexture from "./InstancedTexture";
-import { Vector3 } from "./Physics";
+export default BitmapText;
 /**
  * BitmapText class for rendering text using a bitmap font texture
  * @param {string} text - The text to display
@@ -20,24 +17,24 @@ import { Vector3 } from "./Physics";
  * @param {boolean} useLighting - Whether the text should react to lighting (default: false)
  */
 declare class BitmapText {
-    text: string;
-    texturePath: string;
-    fontSize: number;
-    color: Color;
-    position: Vector3;
-    rotation: number;
-    letters: string;
-    letterSpacing: number;
-    frameWidth: number;
-    frameHeight: number;
-    framesPerRow: number;
-    totalFrames: number;
-    pixelArt: boolean;
+    constructor(text: any, texturePath: any, letters: any, letterSpacing: any, frameWidth: any, frameHeight: any, framesPerRow: any, totalFrames: any, pixelArt: any, fontSize: any, color: any, position: any, rotation: any, useLighting?: boolean);
+    text: any;
+    texturePath: any;
+    fontSize: any;
+    color: any;
+    position: any;
+    rotation: any;
+    letters: any;
+    letterSpacing: any;
+    frameWidth: any;
+    frameHeight: any;
+    framesPerRow: any;
+    totalFrames: any;
+    pixelArt: any;
     useLighting: boolean;
     gameObject: GameObject;
-    letterDictionary: Record<string, number>;
+    letterDictionary: {};
     texture: InstancedTexture;
-    constructor(text: string, texturePath: string, letters: string, letterSpacing: number, frameWidth: number, frameHeight: number, framesPerRow: number, totalFrames: number, pixelArt: boolean, fontSize: number, color: Color, position: Vector3, rotation: number, useLighting?: boolean);
     /**
      * @method setColor
      * @description Updates the color of the bitmap text
@@ -75,5 +72,6 @@ declare class BitmapText {
      */
     setLetterSpacing(letterSpacing: number): void;
 }
-export default BitmapText;
-//# sourceMappingURL=BitmapText.d.ts.map
+import GameObject from "./components/GameObject.js";
+import InstancedTexture from "./InstancedTexture.js";
+import { Vector3 } from "./Physics.js";

package/dist/types/src/Camera.d.ts

@@ -0,0 +1,122 @@
+export default Camera;
+/**
+ * @class Camera
+ * @description A view into the scene with its own transform (position, zoom,
+ * rotation) and a viewport rectangle. Multiple cameras can be added to an
+ * Emerald instance to render split-screen or picture-in-picture. The viewport
+ * is expressed in normalized [0..1] coordinates with the origin at the
+ * bottom-left of the canvas (matching WebGL).
+ *
+ * Backward compatible with the previous inline camera: position is stored
+ * negated internally, and setPosition/getPosition/setZoom/getZoom behave the
+ * same, so EventManager and CameraController are unaffected.
+ *
+ * @example
+ * const left = new Camera({ viewport: { x: 0, y: 0, width: 0.5, height: 1 } });
+ * const right = new Camera({ viewport: { x: 0.5, y: 0, width: 0.5, height: 1 } });
+ * emerald.setCameras([left, right]);
+ */
+declare class Camera {
+    constructor(options?: {});
+    transform: Transform;
+    viewport: {
+        x: any;
+        y: any;
+        width: any;
+        height: any;
+    };
+    active: boolean;
+    clearColor: any;
+    ignoreLayers: Set<any>;
+    onlyLayers: Set<any>;
+    excludeFromPost: boolean;
+    pixelSnap: boolean;
+    /**
+     * @method setPixelSnap
+     * @description When true, the camera's rendered position is rounded to whole
+     * screen pixels each frame (the stored position stays smooth). Use it for
+     * pixel-art games to eliminate sub-pixel shimmer and tile seams while a
+     * smooth-follow camera moves. Ignored while the camera is rotated.
+     * @param {boolean} snap
+     * @returns {Camera} - this
+     */
+    setPixelSnap(snap: boolean): Camera;
+    /**
+     * @method setExcludeFromPost
+     * @description When true, this camera renders straight to the screen AFTER the
+     * post-processing pass instead of into the post-processed scene buffer. Use it
+     * for HUD/UI cameras so effects like bloom don't affect the interface.
+     * @param {boolean} exclude
+     * @returns {Camera} - this
+     */
+    setExcludeFromPost(exclude: boolean): Camera;
+    /**
+     * @method setOnlyLayers
+     * @description Restricts the camera to rendering only the given layers (or
+     * pass null to clear the restriction).
+     * @param {number[]|null} layers
+     * @returns {Camera} - this
+     */
+    setOnlyLayers(layers: number[] | null): Camera;
+    /**
+     * @method setIgnoreLayers
+     * @description Replaces the set of layers this camera skips when rendering.
+     * @param {number[]} layers - Layer indices to ignore
+     * @returns {Camera} - this
+     */
+    setIgnoreLayers(layers: number[]): Camera;
+    /**
+     * @method ignoreLayer
+     * @description Adds a single layer to the ignore set.
+     * @param {number} layer
+     * @returns {Camera} - this
+     */
+    ignoreLayer(layer: number): Camera;
+    /**
+     * @method setPosition
+     * @description Sets the world-space center of the camera.
+     */
+    setPosition(x: any, y: any, z?: number): void;
+    /**
+     * @method getPosition
+     * @description Returns the world-space center of the camera.
+     */
+    getPosition(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /**
+     * @method setZoom
+     * @description Sets the zoom (1 = default, >1 zooms in).
+     */
+    setZoom(zoom: any): void;
+    /**
+     * @method getZoom
+     * @returns {number}
+     */
+    getZoom(): number;
+    /**
+     * @method setRotation
+     * @description Sets the camera rotation in radians.
+     */
+    setRotation(radians: any): void;
+    /**
+     * @method getRotation
+     * @returns {number}
+     */
+    getRotation(): number;
+    /**
+     * @method setViewport
+     * @description Sets the normalized viewport rectangle (origin bottom-left).
+     * @returns {Camera} - this
+     */
+    setViewport(x: any, y: any, width: any, height: any): Camera;
+    /**
+     * @method setActive
+     * @description Enables/disables rendering of this camera.
+     * @returns {Camera} - this
+     */
+    setActive(active: any): Camera;
+}
+import Transform from "./Transform.js";

package/dist/types/src/CameraController.d.ts

@@ -0,0 +1,107 @@
+export default CameraController;
+/**
+ * @class CameraController
+ * @description Drives an Emerald camera with follow, bounds clamping, zoom and
+ * screen shake. Construct it with `emerald.camera` and call `update(dt)` once
+ * per frame.
+ *
+ * @example
+ * const cam = new CameraController(emerald.camera);
+ * cam.follow(player.gameObject, 0.1).setBounds(-1000, -1000, 1000, 1000);
+ * // in the loop: cam.update(deltaTime);
+ */
+declare class CameraController {
+    /**
+     * @param {Object} camera - The Emerald camera (e.g. emerald.camera)
+     */
+    constructor(camera: any);
+    camera: any;
+    target: any;
+    smoothing: number;
+    bounds: {
+        minX: any;
+        minY: any;
+        maxX: any;
+        maxY: any;
+    };
+    position: {
+        x: any;
+        y: any;
+    };
+    shakeIntensity: number;
+    shakeDuration: number;
+    shakeElapsed: number;
+    deadzone: {
+        x: number;
+        y: number;
+    };
+    /**
+     * @method setDeadzone
+     * @description Sets a centered follow deadzone. The camera only scrolls when
+     * the target moves outside this box, giving the player room to move without
+     * the camera reacting to every step. Pass 0/0 or null to disable.
+     * @param {number} halfWidth - Horizontal half-extent in world units
+     * @param {number} halfHeight - Vertical half-extent in world units
+     * @returns {CameraController} - this
+     */
+    setDeadzone(halfWidth: number, halfHeight: number): CameraController;
+    /**
+     * @method follow
+     * @description Follows a target each frame.
+     * @param {Object} target - GameObject/Instance (uses transform.position) or a { x, y }
+     * @param {number} smoothing - 0..1, higher snaps faster (1 = instant)
+     * @returns {CameraController} - this
+     */
+    follow(target: any, smoothing?: number): CameraController;
+    /**
+     * @method stopFollow
+     * @description Stops following the current target.
+     * @returns {CameraController} - this
+     */
+    stopFollow(): CameraController;
+    /**
+     * @method setBounds
+     * @description Clamps the camera center to a world-space rectangle.
+     * @returns {CameraController} - this
+     */
+    setBounds(minX: any, minY: any, maxX: any, maxY: any): CameraController;
+    /**
+     * @method clearBounds
+     * @description Removes bounds clamping.
+     * @returns {CameraController} - this
+     */
+    clearBounds(): CameraController;
+    /**
+     * @method setZoom
+     * @description Sets the camera zoom (1 = default, >1 zooms in).
+     * @returns {CameraController} - this
+     */
+    setZoom(zoom: any): CameraController;
+    /**
+     * @method getZoom
+     * @returns {number} - The current zoom
+     */
+    getZoom(): number;
+    /**
+     * @method setPosition
+     * @description Immediately moves the camera center.
+     * @returns {CameraController} - this
+     */
+    setPosition(x: any, y: any): CameraController;
+    /**
+     * @method shake
+     * @description Triggers a screen shake that decays over its duration.
+     * @param {number} intensity - Max offset in world units
+     * @param {number} duration - Duration in seconds
+     * @returns {CameraController} - this
+     */
+    shake(intensity: number, duration: number): CameraController;
+    /** @private */
+    private _targetPosition;
+    /**
+     * @method update
+     * @description Advances follow/shake and applies the result to the camera.
+     * @param {number} dt - Seconds since the last frame
+     */
+    update(dt: number): void;
+}

package/dist/types/src/CanvasText.d.ts

@@ -0,0 +1,91 @@
+export default CanvasText;
+/**
+ * @class CanvasText
+ * @description Renders dynamic text using a system font by drawing to an
+ * offscreen 2D canvas and uploading it as a texture. Unlike BitmapText it needs
+ * no font sheet and supports any installed font. It's a Drawable component;
+ * `CanvasText.create()` returns a ready GameObject sized to the text.
+ *
+ * @example
+ * const label = CanvasText.create("Score: 0", {
+ *   font: "bold 28px monospace", color: "#6ee7b7", screenSpace: true,
+ * });
+ * label.transform.position = new Vector3(-300, 260, 100);
+ * scene.add(label);
+ * label.getComponent(CanvasText).setText("Score: 120");
+ */
+declare class CanvasText extends Drawable {
+    /**
+     * @method wrapText
+     * @description Pure helper that breaks `text` into rendered lines. Honors
+     * explicit `\n` line breaks and, when `maxWidth > 0`, greedily word-wraps each
+     * paragraph so no line measures wider than `maxWidth`. A single word longer
+     * than `maxWidth` is kept on its own line rather than being split.
+     * @param {(s:string)=>number} measure - Returns the pixel width of a string
+     * @param {string} text - The text to lay out
+     * @param {number} maxWidth - Wrap width in pixels (0 disables wrapping)
+     * @returns {string[]} - The lines to render top to bottom
+     */
+    static wrapText(measure: (s: string) => number, text: string, maxWidth: number): string[];
+    /**
+     * @method create
+     * @description Convenience factory returning a GameObject sized to the text.
+     * @param {string} text
+     * @param {Object} [options] - { name, position, screenSpace, font, color,
+     *   maxWidth, align, lineHeight, padding }
+     * @returns {GameObject}
+     */
+    static create(text: string, options?: any): GameObject;
+    constructor(text: any, options?: {});
+    font: any;
+    fillStyle: any;
+    padding: any;
+    maxWidth: any;
+    align: any;
+    lineHeight: any;
+    /** @private */
+    private _canvas;
+    /** @private */
+    private _ctx;
+    useTexture: boolean;
+    width: number;
+    height: number;
+    /**
+     * @method setText
+     * @description Re-renders the text and re-uploads the texture. If attached to
+     * a GameObject, its scale is updated to match the new size.
+     * @param {string} text
+     */
+    setText(text: string): void;
+    text: string;
+    /**
+     * @method setMaxWidth
+     * @description Sets the wrap width in pixels (0 disables wrapping) and
+     * re-renders.
+     * @param {number} px
+     */
+    setMaxWidth(px: number): void;
+    /**
+     * @method setAlign
+     * @description Sets horizontal alignment ("left" | "center" | "right") and
+     * re-renders.
+     * @param {string} align
+     */
+    setAlign(align: string): void;
+    /**
+     * @method setColor
+     * @description Sets the text color (CSS color string) and re-renders.
+     * @param {string} cssColor
+     */
+    setColor(cssColor: string): void;
+    /**
+     * @method getSize
+     * @returns {{width:number, height:number}} - The canvas pixel size
+     */
+    getSize(): {
+        width: number;
+        height: number;
+    };
+}
+import Drawable from "./Drawable.js";
+import GameObject from "./components/GameObject.js";

package/dist/types/src/CollisionLayers.d.ts

@@ -0,0 +1,58 @@
+export default CollisionLayers;
+declare class CollisionLayers {
+    /**
+     * @method define
+     * @description Registers one or more named layers (in order), assigning each
+     * the next free category bit. Re-defining an existing name returns its
+     * existing bit. Returns the bit of the last name passed.
+     * @param {...string} names
+     * @returns {number}
+     */
+    static define(...names: string[]): number;
+    /**
+     * @method bit
+     * @description Returns the category bit for a layer name, registering it on
+     * first use.
+     * @param {string} name
+     * @returns {number}
+     */
+    static bit(name: string): number;
+    /**
+     * @method mask
+     * @description Computes a combined mask from layer names. Accepts a single
+     * name, an array of names, a number (passed through), or "all"/null for
+     * "collide with everything".
+     * @param {string|string[]|number|null} layers
+     * @returns {number}
+     */
+    static mask(layers: string | string[] | number | null): number;
+    /**
+     * @method reset
+     * @description Clears all registered layers (mainly for tests).
+     */
+    static reset(): void;
+}
+declare namespace CollisionLayers {
+    export let _bits: Map<any, any>;
+    export let _next: number;
+    export { ALL_BITS as ALL };
+}
+/**
+ * @class CollisionLayers
+ * @description A small registry that maps human-readable layer names to the
+ * category bits planck uses for collision filtering, so games can say
+ * "players collide with ground and enemies, but not with each other" without
+ * juggling raw bitmasks.
+ *
+ * Two fixtures collide only if each one's category is in the other's mask, so
+ * filtering is symmetric by construction. Up to 16 distinct layers are
+ * supported (planck filter bits are 16-bit).
+ *
+ * @example
+ * CollisionLayers.define("ground", "player", "enemy", "pickup");
+ * playerCollider.setCategory("player");
+ * playerCollider.setCollidesWith(["ground", "enemy", "pickup"]);
+ * enemyCollider.setCategory("enemy");
+ * enemyCollider.setCollidesWith(["ground", "player"]); // enemies ignore each other
+ */
+declare const ALL_BITS: 65535;

package/dist/types/{Color.d.ts → src/Color.d.ts}

@@ -1,3 +1,4 @@
+export default Color;
 /**
  * @class Color
  * @description Represents a color
@@ -7,11 +8,9 @@
  * @param {number} a - The alpha value
  */
 declare class Color {
-    r: number;
-    g: number;
-    b: number;
+    constructor(r: any, g: any, b: any, a?: number);
+    r: any;
+    g: any;
+    b: any;
     a: number;
-    constructor(r: number, g: number, b: number, a?: number);
 }
-export default Color;
-//# sourceMappingURL=Color.d.ts.map