nexus-2d 0.0.1 → 0.0.3

package/dist/types/engine/sprite.d.ts

@@ -0,0 +1,158 @@
+export class Sprite extends Node {
+    /**
+     *
+     * @param {string} name
+     * @param {SpriteAtlas} atlas
+     * @param {*} options
+     */
+    constructor(name: string, atlas: SpriteAtlas, options?: any);
+    atlas: SpriteAtlas;
+    frameWidth: any;
+    frameHeight: any;
+    frame: any;
+    offset: {
+        x: any;
+        y: any;
+    };
+    flipH: boolean;
+    flipV: boolean;
+    modulate: any;
+    opaque: any;
+    framesPerRow: number;
+    /**
+ * convert frame index to atlas coordinates
+ *
+ * Example: 32x32 sprites in 256x256 atlas = 8 frames per row
+ * Frame 0 = (0, 0)
+ * Frame 5 = (160, 0)  // 5 * 32 = 160
+ * Frame 8 = (0, 32)   // wraps to next row
+ */
+    getFrameRect(frameIndex: any): {
+        x: number;
+        y: number;
+        width: any;
+        height: any;
+    };
+    /**
+     * draw sprite to canvas
+     *
+     *
+     * 1. Calculate world position (Node system handles this)
+     * 2. Apply offset (pivot point)
+     * 3. Get source rect from frame index
+     * 4. Blit pixels using tessera's drawAtlasRegionToCanvas
+     *
+     * Note: We're NOT handling rotation/scale YET. That requires
+     * per-pixel transforms which is slow in pure JS. For now,
+     * rotation/scale affects position but not the sprite pixels.
+     *
+     * Future optimization: pre-render rotated sprites to cache,
+     *
+     *
+     * If your atlas has no transparency (RGBA alpha always 255) and you don't need tint, call:
+     * @param {Camera2D} camera
+     */
+    _draw(canvas: any, camera: Camera2D): void;
+    /**
+     * Utility: set pivot to center of sprite
+     */
+    centerOrigin(): void;
+}
+/**
+ *
+ *
+ * why separate from Sprite:
+ * - Not all sprites need animation (static decorations)
+ * - Animation state (current frame, time accumulator) is extra memory
+ * - Keeps Sprite class lean for performance
+ *
+ * Common use case: character walk cycles, enemy attack patterns
+ */
+export class AnimatedSprite extends Sprite {
+    animations: any;
+    currentAnimation: any;
+    currentFrameIndex: number;
+    frameTimer: number;
+    playing: boolean;
+    loop: boolean;
+    onAnimationFinished: any;
+    /**
+     * start playing an animation
+     * @param {string} animName
+     * @param {boolean} restart
+     * @returns
+     */
+    play(animName: string, restart?: boolean): void;
+    /**
+     * stop animation (freeze on current frame)
+     */
+    stop(): void;
+    /**
+     * pause (can resume with play())
+     */
+    pause(): void;
+    /**
+     * update animation state
+     *
+     * how frame timing works:
+     * - animation has target FPS (e.g., 12 fps = 0.083s per frame)
+     * - accumulate delta time until we hit frame duration
+     * - advance to next frame
+     * - loop or stop at end
+     *
+     * @param {number} delta
+     * @returns
+     */
+    _process(delta: number): void;
+    /**
+     * check if specific animation is playing
+     * @param {string} animName
+     * @returns
+     */
+    isPlaying(animName?: string): boolean;
+    /**
+     * get current animation progress (0.0 to 1.0)
+     */
+    getProgress(): number;
+}
+/**
+ * spriteAtlas - helper for managing shared atlases
+ *
+ *
+ * - Multiple sprites often share the same atlas (all enemies, all UI icons)
+ * - Loading atlas once and reusing saves memory
+ * - Provides utilities for common atlas patterns (grid, packed)
+ */
+export class SpriteAtlas {
+    /**
+     * Utility: generate sequential frame array
+     * Example: getFrameRange(0, 7) -> [0,1,2,3,4,5,6,7]
+     */
+    static getFrameRange(start: any, end: any): any[];
+    constructor(renderer: any, path: any, options?: {});
+    path: any;
+    image: any;
+    frameWidth: any;
+    frameHeight: any;
+    framesPerRow: number;
+    framesPerCol: number;
+    totalFrames: number;
+    /**
+     * create a sprite from this atlas
+     * @param {*} name
+     * @param {*} frame
+     * @param {*} options
+     * @returns
+     */
+    createSprite(name: any, frame?: any, options?: any): Sprite;
+    /**
+     * Create animated sprite from this atlas
+     * @param {*} name
+     * @param {*} animations
+     * @param {*} options
+     * @returns
+     */
+    createAnimatedSprite(name: any, animations: any, options?: any): AnimatedSprite;
+}
+import { Node } from './core.js';
+import { Camera2D } from './camera.js';

package/dist/types/engine/tiled.d.ts

@@ -0,0 +1,21 @@
+export class Tiled extends Node {
+    constructor(renderer: any, path: any, opts?: {}, opaque?: any[]);
+    basePath: string;
+    opts: {};
+    opaque: any[];
+    renderer: any;
+    json: any;
+    lastgid: any[];
+    tiles: any[];
+    layers: any[];
+    collisionObjects: any[];
+    processTilesets(tilesets: any): void;
+    /**
+     *
+     * @param {Array<any>} c
+     */
+    collisionLayerChildren(c: Array<any>): void;
+    processLayers(layers: any): void;
+    printDebug(): void;
+}
+import { Node } from './core.js';

package/dist/types/engine/vec2pool.d.ts

@@ -0,0 +1,17 @@
+export const vec2Pool: Vec2Pool;
+declare class Vec2Pool {
+    constructor(initialSize?: number);
+    available: Vec2[];
+    inUse: Set<any>;
+    totalCreated: number;
+    acquire(x?: number, y?: number): Vec2;
+    release(vec: any): void;
+    reset(): void;
+    stats(): {
+        available: number;
+        inUse: number;
+        total: number;
+    };
+}
+import { Vec2 } from "planck";
+export {};

package/dist/types/index.d.ts

@@ -1 +1,11 @@
 export * from "./engine/core.js";
+export * from "./engine/cam.js";
+export * from "./engine/controllers.js";
+export * from "./engine/lib.js";
+export * from "./engine/audio.js";
+export * from "./engine/Charactercontrollerv2.js";
+export * from "./engine/lerp.js";
+export * from "./engine/particles.js";
+export * from "./engine/physicsv2.js";
+export * from "./engine/sprite.js";
+export * from "./engine/tiled.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-2d",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "main": "index.js",
   "author": "sk",
   "license": "GPL-3.0-or-later",
@@ -8,7 +8,10 @@
     "access": "public"
   },
   "dependencies": {
-    "tessera.js": "^0.2.5"
+    "planck": "^1.4.2"
+  },
+  "peerDependencies": {
+    "tessera.js": "^1.0.2"
   },
   "type": "module",
   "module": "dist/esm/index.js",
@@ -37,4 +40,4 @@
     "rollup-plugin-terser": "^7.0.2",
     "typescript": "^5.9.3"
   }
-}
+}