nexus-2d 0.0.1 → 0.0.2

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

@@ -0,0 +1,112 @@
+export class CharacterController2D extends RigidBody2D {
+    speed: any;
+    acceleration: any;
+    airAcceleration: any;
+    airFriction: any;
+    jumpForce: any;
+    maxFallSpeed: any;
+    jumpCutMultiplier: any;
+    coyoteTime: any;
+    jumpBufferTime: any;
+    coyoteTimer: number;
+    jumpBufferTimer: number;
+    grounded: boolean;
+    wasGrounded: boolean;
+    jumping: boolean;
+    state: string;
+    moveInput: number;
+    jumpPressed: boolean;
+    jumpHeld: boolean;
+    jumpReleased: boolean;
+    groundContacts: Set<any>;
+    onJump: any;
+    onLand: any;
+    spriteNode: any;
+    animatedSprite: any;
+    collisionWidth: any;
+    collisionHeight: any;
+    collisionPaddingX: any;
+    collisionPaddingY: any;
+    debugDraw: any;
+    debugColor: any;
+    setupSprite(sprite: any): void;
+    setupCollision(): void;
+    setupAnimations(animatedSprite: any): void;
+    prevState: any;
+    updateAnimations(): void;
+    getAnimationForState(state: any): any;
+    handleCollisionEnter(other: any, contact: any): void;
+    handleCollisionStay(other: any, contact: any): void;
+    handleCollisionExit(other: any, contact: any): void;
+    updateTimers(delta: any): void;
+    handleMovement(delta: any): void;
+    handleJump(delta: any): void;
+    updateState(): void;
+    setMoveInput(direction: any): void;
+    setJumpInput(pressed: any, held: any, released: any): void;
+}
+export class CharacterInputController {
+    constructor(character: any, inputMap: any);
+    character: any;
+    inputMap: any;
+    prevJumpHeld: boolean;
+    update(): void;
+}
+/**
+ * TopDownController - 8-directional movement for dynamic bodies
+ *
+ * Uses high damping for tight, responsive controls
+ * Dynamic body type allows collision with static geometry
+ */
+export class TopDownController extends RigidBody2D {
+    speed: any;
+    acceleration: any;
+    canDash: any;
+    dashSpeed: any;
+    dashDuration: any;
+    dashCooldown: any;
+    isDashing: boolean;
+    dashTimer: number;
+    dashCooldownTimer: number;
+    dashDirection: {
+        x: number;
+        y: number;
+    };
+    moveInput: {
+        x: number;
+        y: number;
+    };
+    dashInput: boolean;
+    state: string;
+    collisionWidth: any;
+    collisionHeight: any;
+    collisionPaddingX: any;
+    collisionPaddingY: any;
+    debugDraw: any;
+    debugColor: any;
+    onDashStart: any;
+    onDashEnd: any;
+    spriteNode: any;
+    animatedSprite: any;
+    setupSprite(sprite: any): void;
+    setupCollision(): void;
+    setupAnimations(animatedSprite: any): void;
+    prevState: any;
+    updateAnimations(): void;
+    getAnimationForState(state: any): any;
+    handleNormalMovement(delta: any): void;
+    handleDashMovement(delta: any): void;
+    startDash(): void;
+    endDash(): void;
+    updateState(): void;
+    setMoveInput(x: any, y: any): void;
+    setDashInput(pressed: any): void;
+}
+export class TopDownInputController {
+    constructor(character: any, inputMap: any);
+    character: any;
+    inputMap: any;
+    prevDashHeld: boolean;
+    update(): void;
+}
+import { RigidBody2D } from "./physicsv2.js";

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

@@ -0,0 +1,183 @@
+/**
+ * AudioManager - high-level audio management
+ *
+ * Features:
+ * - Named audio assets (play by name, not handle)
+ * - Volume groups (SFX, music, master)
+ * - Fade in/out effects
+ * - Spatial audio (2D positional sound)
+ * - Audio groups (random variation)
+ * - Preloading
+ *
+ * Why this wrapper:
+ * - tessera.js is low-level (handles, no names)
+ * - Need organized asset management
+ * - Need fade effects for polish
+ * - Need volume groups for settings
+ */
+export class AudioManagerClass {
+    audio: any;
+    sounds: Map<any, any>;
+    music: Map<any, any>;
+    masterVolume: number;
+    sfxVolume: number;
+    musicVolume: number;
+    activeSounds: Map<any, any>;
+    activeMusic: any;
+    groups: Map<any, any>;
+    listenerPosition: {
+        x: number;
+        y: number;
+    };
+    maxHearingDistance: number;
+    /**
+     * Initialize with tessera.js audio interface
+     *
+     * @param {Object} audioInterface - renderer.audio from tessera.js
+     */
+    init(audioInterface: any): void;
+    /**
+     * Load sound effect (fully loaded into memory)
+     *
+     * @param {string} name - Unique name for this sound
+     * @param {string} filePath - Path to audio file
+     * @returns {Promise<boolean>} - Success
+     */
+    loadSound(name: string, filePath: string): Promise<boolean>;
+    /**
+     * Load music (streamed from disk)
+     *
+     * @param {string} name - Unique name for this music
+     * @param {string} filePath - Path to audio file
+     * @returns {Promise<boolean>} - Success
+     */
+    loadMusic(name: string, filePath: string): Promise<boolean>;
+    /**
+     * Play sound effect
+     *
+     * @param {string} name - Sound name
+     * @param {Object} options - { volume, pitch, loop }
+     * @returns {boolean} - Success
+     */
+    playSound(name: string, options?: any): boolean;
+    /**
+     * Play music with fade options
+     *
+     * @param {string} name - Music name
+     * @param {Object} options - { fadeIn, loop, volume }
+     * @returns {boolean} - Success
+     */
+    playMusic(name: string, options?: any): boolean;
+    /**
+     * Stop music with fade out
+     *
+     * @param {string} name - Music name
+     * @param {Object} options - { fadeOut }
+     */
+    stopMusic(name: string, options?: any): void;
+    /**
+     * Pause music
+     */
+    pauseMusic(name: any): void;
+    /**
+     * Resume music
+     */
+    resumeMusic(name: any): void;
+    /**
+     * Play sound with 2D spatial positioning
+     *
+     * Volume falls off with distance from listener
+     *
+     * @param {string} name - Sound name
+     * @param {number} x - Sound world X
+     * @param {number} y - Sound world Y
+     * @param {number} listenerX - Listener world X (camera/player)
+     * @param {number} listenerY - Listener world Y
+     */
+    playSoundAt(name: string, x: number, y: number, listenerX: number, listenerY: number): void;
+    /**
+     * Set master volume (affects all audio)
+     */
+    setMasterVolume(volume: any): void;
+    /**
+     * Set SFX volume group
+     */
+    setSFXVolume(volume: any): void;
+    /**
+     * Set music volume group
+     */
+    setMusicVolume(volume: any): void;
+    /**
+     * Update volumes for all active audio
+     */
+    updateAllVolumes(): void;
+    /**
+     * Create audio group for random variation
+     *
+     * Example: footsteps group contains step1, step2, step3
+     *
+     * @param {string} groupName - Group name
+     * @param {Array<string>} soundNames - Sound names in group
+     */
+    createGroup(groupName: string, soundNames: Array<string>): void;
+    /**
+     * Play random sound from group
+     */
+    playRandomFromGroup(groupName: any, options?: {}): boolean;
+    /**
+     * Update fade effects (call every frame)
+     *
+     * @param {number} delta - Time delta in seconds
+     */
+    update(delta: number): void;
+    /**
+     * Check if sound is playing
+     */
+    isSoundPlaying(name: any): any;
+    /**
+     * Check if music is playing
+     */
+    isMusicPlaying(name: any): any;
+    /**
+     * Unload sound
+     */
+    unloadSound(name: any): void;
+    /**
+     * Unload music
+     */
+    unloadMusic(name: any): void;
+    /**
+     * Unload all audio
+     */
+    unloadAll(): void;
+    /**
+     * Get audio statistics
+     */
+    getStats(): {
+        soundsLoaded: number;
+        musicLoaded: number;
+        activeSounds: number;
+        musicPlaying: boolean;
+        masterVolume: number;
+        sfxVolume: number;
+        musicVolume: number;
+    };
+}
+export const AudioManager: AudioManagerClass;
+/**
+ * AudioPresets - common audio patterns
+ */
+export class AudioPresets {
+    /**
+     * UI sound pack
+     */
+    static loadUIAudio(): Promise<void>;
+    /**
+     * Player action sounds
+     */
+    static loadPlayerAudio(): Promise<void>;
+    /**
+     * Background music
+     */
+    static loadMusicTracks(): Promise<void>;
+}

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

@@ -0,0 +1,94 @@
+export function vec2(x?: number, y?: number): {
+    x: number;
+    y: number;
+};
+export class Camera2D extends Node {
+    zoom: number;
+    /**
+     * @type {Viewport}
+     */
+    viewport: Viewport;
+    near: number;
+    far: number;
+    worldZoom: number;
+    projectionDirty: boolean;
+    frustum: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        near: number;
+        far: number;
+    };
+    bounds: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    viewWidth: number;
+    viewHeight: number;
+    cullingEnabled: boolean;
+    _viewMatrix: any;
+    _projectionMatrix: any;
+    _viewProjectionMatrix: any;
+    setBounds(bounds: any): void;
+    /**
+     * viewport
+     * @param {*} width
+     * @param {*} height
+     */
+    setViewSize(width: any, height: any): void;
+    /**
+     * visible space in world
+     */
+    _updateFrustum(): void;
+    worldToScreen(worldX: any, worldY: any, applyViewport?: boolean): {
+        x: any;
+        y: any;
+    };
+    screenToWorld(screenX: any, screenY: any): {
+        x: number;
+        y: number;
+    };
+    getVisibility(x: any, y: any, width?: number, height?: number): 0 | 1 | 2;
+    isVisible(x: any, y: any, margin?: number): boolean;
+    /**
+     * Check if an axis-aligned bounding box (AABB) is visible in the camera view
+     * @param {number} worldX - Center X of the AABB in world space
+     * @param {number} worldY - Center Y of the AABB in world space
+     * @param {number} width - Width of the AABB
+     * @param {number} height - Height of the AABB
+     * @returns {boolean} True if the AABB is at least partially visible
+     */
+    isAABBVisible(worldX: number, worldY: number, width: number, height: number): boolean;
+    getVisibleBounds(): {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+    moveLocal(dx: any, dy: any): void;
+    moveWorld(dx: any, dy: any): void;
+    setPosition(x: any, y: any): void;
+    /**
+ * Zoom with optional pivot point (world space)
+ * Pivot allows zooming toward a specific point (like mouse position)
+ */
+    zoomTo(factor: any, pivotX?: any, pivotY?: any): void;
+    applyShake(intensity: any, decay?: number): number;
+}
+export class Viewport {
+    constructor(x: any, y: any, width: any, height: any);
+    x: any;
+    y: any;
+    width: any;
+    height: any;
+    scissorEnabled: boolean;
+    contains(screenX: any, screenY: any): boolean;
+    setScissor(enabled: any): void;
+    shouldClip(canvasX: any, canvasY: any, margin?: number): boolean;
+}
+import { Node } from "./core.js";

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

@@ -0,0 +1,142 @@
+/**
+ * Camera2D - transforms world space to screen space
+ *
+ * Why extend Node:
+ * - Inherits transform system (position, rotation)
+ * - Can be child of other nodes (camera attached to vehicle)
+ * - Participates in scene graph updates
+ *
+ * Common use cases:
+ * - Follow player smoothly
+ * - Screen shake effects
+ * - Zoom in/out
+ * - Split-screen (multiple cameras, multiple viewports)
+ */
+export class Camera2D extends Node {
+    zoom: number;
+    viewport: any;
+    target: any;
+    followSmoothing: number;
+    deadzone: {
+        x: number;
+        y: number;
+    };
+    limits: {
+        minX: any;
+        minY: any;
+        maxX: any;
+        maxY: any;
+    };
+    limitSmoothing: number;
+    shakeAmount: number;
+    shakeDuration: number;
+    shakeDecay: number;
+    shakeOffset: {
+        x: number;
+        y: number;
+    };
+    screenWidth: number;
+    screenHeight: number;
+    setTarget(target: any, options?: {}): void;
+    setLimits(minX: any, minY: any, maxX: any, maxY: any): void;
+    shake(amount: any, duration?: number): void;
+    worldToScreen(worldX: any, worldY: any): {
+        x: number;
+        y: number;
+    };
+    screenToWorld(screenX: any, screenY: any): {
+        x: any;
+        y: any;
+    };
+    isVisible(worldX: any, worldY: any, margin?: number): boolean;
+    isAABBVisible(worldX: any, worldY: any, width: any, height: any): boolean;
+    getVisibleBounds(): {
+        minX: any;
+        minY: any;
+        maxX: any;
+        maxY: any;
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Viewport - defines a rectangular region of the screen
+ *
+ * why viewports exist:
+ * - Split-screen multiplayer (2-4 cameras, each with own viewport)
+ * - Picture-in-picture (minimap)
+ * - UI overlays (render game to viewport, UI to full screen)
+ *
+ * common use case: 2-player split-screen
+ * Player 1 viewport: (0, 0, 400, 600)
+ * Player 2 viewport: (400, 0, 400, 600)
+ */
+export class Viewport {
+    /**
+     * create viewport from canvas (full screen)
+     */
+    static fromCanvas(canvas: any): Viewport;
+    constructor(x: any, y: any, width: any, height: any);
+    x: any;
+    y: any;
+    width: any;
+    height: any;
+    /**
+     * Check if screen point is inside viewport
+     */
+    contains(screenX: any, screenY: any): boolean;
+    /**
+     * get aspect ratio (useful for maintaining proportions)
+     */
+    getAspectRatio(): number;
+}
+/**
+ * CameraController - common camera behaviors
+ *
+ * - Camera2D is low-level (transform math)
+ * - CameraController is high-level (gameplay behaviors)
+ * - Swap controllers for different game types
+ */
+export class CameraController extends Node {
+    constructor(name: any, camera: any);
+    camera: any;
+}
+/**
+ * FollowCameraController - smooth following with lookahead
+ *
+ * Features:
+ * - Smooth following
+ * - Lookahead (camera shows more space ahead of player)
+ * - Speed-based zoom out (see more when moving fast)
+ */
+export class FollowCameraController extends CameraController {
+    constructor(camera: any, target: any, options?: {});
+    target: any;
+    smoothing: any;
+    lookahead: any;
+    lookaheadSmoothing: any;
+    currentLookahead: {
+        x: number;
+        y: number;
+    };
+    zoomSpeed: any;
+    minZoom: any;
+    maxZoom: any;
+}
+/**
+ * PlatformerCameraController - platformer-specific camera
+ *
+ * Features:
+ * - Vertical lookahead (look down when falling, up when jumping)
+ * - Horizontal smoothing (don't jitter left/right)
+ * - Jump anticipation (camera rises slightly before player jumps)
+ */
+export class PlatformerCameraController extends CameraController {
+    constructor(camera: any, target: any, options?: {});
+    target: any;
+    horizontalSmoothing: any;
+    verticalSmoothing: any;
+    verticalLookahead: any;
+    currentVerticalOffset: number;
+}
+import { Node } from './core.js';