@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/systems/NicePlatformer.d.ts

@@ -0,0 +1,158 @@
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export type JumpType = 'normal' | 'double' | 'triple' | 'wall' | 'spring' | 'ladder';
+export type PlatformType = 'static' | 'moving' | 'falling' | 'bouncy' | 'one-way' | 'slippery' | 'conveyor' | 'crumbling' | 'sinking';
+export interface PlatformerCharacter {
+    id: string;
+    position: Vec2;
+    velocity: Vec2;
+    isGrounded: boolean;
+    groundNormal: Vec2;
+    groundPlatformId: string | null;
+    isTouchingWall: boolean;
+    wallNormal: Vec2;
+    wallSide: 'left' | 'right' | null;
+    jumpCount: number;
+    maxJumps: number;
+    isJumping: boolean;
+    jumpHeld: boolean;
+    canJump: boolean;
+    isGrabbingLedge: boolean;
+    ledgePosition: Vec2 | null;
+    coyoteTimeRemaining: number;
+    jumpBufferRemaining: number;
+    wallJumpCooldown: number;
+    lastGroundedTime: number;
+    lastJumpTime: number;
+    facingDirection: 1 | -1;
+    isCrouching: boolean;
+    isSliding: boolean;
+    isDashing: boolean;
+    gravityScale: number;
+    frictionScale: number;
+}
+export interface Platform {
+    id: string;
+    type: PlatformType;
+    position: Vec2;
+    size: Vec2;
+    velocity: Vec2;
+    active: boolean;
+    path: Vec2[];
+    pathIndex: number;
+    pathSpeed: number;
+    pathLoop: boolean;
+    pathPingPong: boolean;
+    pathDirection: 1 | -1;
+    bounceForce?: number;
+    conveyorSpeed?: number;
+    fallDelay?: number;
+    fallTimer?: number;
+    crumbleTime?: number;
+    crumbleTimer?: number;
+    respawnTime?: number;
+    respawnTimer?: number;
+    sinkSpeed?: number;
+    sinkDepth?: number;
+    isFalling?: boolean;
+    isCrumbling?: boolean;
+    isDestroyed?: boolean;
+}
+export interface CollisionResult {
+    collided: boolean;
+    normal: Vec2;
+    penetration: number;
+    platform: Platform | null;
+}
+export interface RaycastHit {
+    hit: boolean;
+    point: Vec2;
+    normal: Vec2;
+    distance: number;
+    platformId: string | null;
+}
+export type PlatformerEventType = 'jump' | 'double-jump' | 'wall-jump' | 'land' | 'fall' | 'ledge-grab' | 'ledge-climb' | 'platform-trigger' | 'platform-fall' | 'platform-respawn' | 'dash' | 'slide';
+export interface PlatformerEvent {
+    type: PlatformerEventType;
+    timestamp: number;
+    characterId: string;
+    data: unknown;
+}
+export type PlatformerEventCallback = (event: PlatformerEvent) => void;
+export interface PlatformerConfig {
+    gravity: number;
+    maxFallSpeed: number;
+    groundFriction: number;
+    airFriction: number;
+    moveSpeed: number;
+    acceleration: number;
+    deceleration: number;
+    airControl: number;
+    jumpForce: number;
+    jumpCutMultiplier: number;
+    maxJumps: number;
+    coyoteTime: number;
+    jumpBufferTime: number;
+    wallSlideSpeed: number;
+    wallJumpForce: Vec2;
+    wallJumpCooldown: number;
+    wallStickTime: number;
+    ledgeGrabEnabled: boolean;
+    ledgeGrabOffset: Vec2;
+    ledgeClimbDuration: number;
+    slopeLimit: number;
+    stepHeight: number;
+    skinWidth: number;
+    dashSpeed: number;
+    dashDuration: number;
+    dashCooldown: number;
+}
+export declare const DEFAULT_PLATFORMER_CONFIG: PlatformerConfig;
+export declare class NicePlatformer {
+    private config;
+    private characters;
+    private platforms;
+    private eventListeners;
+    private nextId;
+    constructor(config?: Partial<PlatformerConfig>);
+    on(event: PlatformerEventType, callback: PlatformerEventCallback): () => void;
+    private emit;
+    createCharacter(position: Vec2): string;
+    removeCharacter(characterId: string): void;
+    getCharacter(id: string): PlatformerCharacter | undefined;
+    createPlatform(type: PlatformType, position: Vec2, size: Vec2, options?: Partial<Platform>): string;
+    removePlatform(platformId: string): void;
+    getPlatform(id: string): Platform | undefined;
+    setMoveInput(characterId: string, direction: number): void;
+    jump(characterId: string): boolean;
+    private performJump;
+    private wallJump;
+    releaseJump(characterId: string): void;
+    crouch(characterId: string, crouching: boolean): void;
+    dash(characterId: string): boolean;
+    grabLedge(characterId: string, ledgePosition: Vec2): void;
+    climbLedge(characterId: string): void;
+    update(deltaTime: number): void;
+    private updateCharacter;
+    private onLand;
+    private onFall;
+    private resolveCollisions;
+    private checkPlatformCollision;
+    private resolvePlatformCollision;
+    private triggerPlatformEffect;
+    private updatePlatforms;
+    private updateMovingPlatform;
+    private updateFallingPlatform;
+    private updateCrumblingPlatform;
+    private respawnPlatform;
+    raycast(origin: Vec2, direction: Vec2, maxDistance: number): RaycastHit;
+    private rayPlatformIntersect;
+    getAllCharacters(): PlatformerCharacter[];
+    getAllPlatforms(): Platform[];
+    getActivePlatforms(): Platform[];
+    private generateId;
+    destroy(): void;
+}
+export declare function createPlatformerSystem(config?: Partial<PlatformerConfig>): NicePlatformer;

package/dist/types/systems/NicePool.d.ts

@@ -0,0 +1,128 @@
+export type PoolId = string;
+export interface PoolableObject {
+    /** Called when object is taken from pool */
+    onSpawn?: () => void;
+    /** Called when object is returned to pool */
+    onDespawn?: () => void;
+    /** Called when pool is destroyed */
+    onDestroy?: () => void;
+    /** Mark object as active/inactive */
+    active?: boolean;
+}
+export interface PoolFactory<T> {
+    /** Create a new instance */
+    create: () => T;
+    /** Reset instance to initial state */
+    reset?: (obj: T) => void;
+    /** Destroy instance */
+    destroy?: (obj: T) => void;
+    /** Validate instance is still usable */
+    validate?: (obj: T) => boolean;
+}
+export interface PoolConfig {
+    /** Initial pool size */
+    initialSize: number;
+    /** Maximum pool size (0 = unlimited) */
+    maxSize: number;
+    /** Expand by this amount when empty */
+    expandSize: number;
+    /** Auto-shrink when many objects unused */
+    autoShrink: boolean;
+    /** Shrink threshold (ratio of unused objects) */
+    shrinkThreshold: number;
+    /** Minimum pool size after shrinking */
+    minSize: number;
+    /** Warmup pool on creation */
+    warmup: boolean;
+    /** Validate objects on acquire */
+    validateOnAcquire: boolean;
+}
+export declare const DEFAULT_POOL_CONFIG: PoolConfig;
+export interface PoolStats {
+    poolId: PoolId;
+    totalCreated: number;
+    totalDestroyed: number;
+    currentSize: number;
+    activeCount: number;
+    availableCount: number;
+    peakUsage: number;
+    acquireCount: number;
+    releaseCount: number;
+    expandCount: number;
+    shrinkCount: number;
+    missCount: number;
+}
+export type PoolEventType = 'acquired' | 'released' | 'expanded' | 'shrunk' | 'created' | 'destroyed' | 'pool-created' | 'pool-destroyed' | 'stats-updated';
+export interface PoolEvent {
+    type: PoolEventType;
+    timestamp: number;
+    poolId: PoolId;
+    data?: unknown;
+}
+export type PoolEventCallback = (event: PoolEvent) => void;
+export declare class Pool<T extends object> {
+    readonly id: PoolId;
+    private factory;
+    private config;
+    private available;
+    private active;
+    private stats;
+    constructor(id: PoolId, factory: PoolFactory<T>, config?: Partial<PoolConfig>);
+    acquire(): T;
+    release(obj: T): void;
+    releaseAll(): void;
+    warmup(count: number): void;
+    expand(count?: number): void;
+    shrink(targetSize?: number): void;
+    private checkShrink;
+    private createObject;
+    private destroyObject;
+    private updateStats;
+    getStats(): PoolStats;
+    getActiveCount(): number;
+    getAvailableCount(): number;
+    getTotalSize(): number;
+    forEach(callback: (obj: T) => void): void;
+    destroy(): void;
+}
+export declare class NicePool {
+    private pools;
+    private eventListeners;
+    on(event: PoolEventType, callback: PoolEventCallback): () => void;
+    private emit;
+    createPool<T extends object>(id: PoolId, factory: PoolFactory<T>, config?: Partial<PoolConfig>): Pool<T>;
+    getPool<T extends object>(id: PoolId): Pool<T> | undefined;
+    hasPool(id: PoolId): boolean;
+    destroyPool(id: PoolId): boolean;
+    acquire<T extends object>(poolId: PoolId): T;
+    release<T extends object>(poolId: PoolId, obj: T): void;
+    getStats(poolId?: PoolId): PoolStats | PoolStats[];
+    getGlobalStats(): {
+        totalPools: number;
+        totalObjects: number;
+        totalActive: number;
+        totalAvailable: number;
+        memoryEstimate: number;
+    };
+    releaseAll(): void;
+    destroy(): void;
+}
+export declare function createPoolManager(): NicePool;
+export declare function createSimplePool<T extends object>(createFn: () => T, config?: Partial<PoolConfig>): Pool<T>;
+export interface Vec2Poolable {
+    x: number;
+    y: number;
+    active?: boolean;
+    onSpawn?: () => void;
+    onDespawn?: () => void;
+}
+export declare function createVec2Pool(initialSize?: number): Pool<Vec2Poolable>;
+export interface Vec3Poolable {
+    x: number;
+    y: number;
+    z: number;
+    active?: boolean;
+    onSpawn?: () => void;
+    onDespawn?: () => void;
+}
+export declare function createVec3Pool(initialSize?: number): Pool<Vec3Poolable>;

package/dist/types/systems/NicePortal.d.ts

@@ -0,0 +1,178 @@
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quat {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export type PortalType = 'linked' | 'one-way' | 'dimension' | 'zone' | 'spawn';
+export type PortalState = 'inactive' | 'activating' | 'active' | 'deactivating' | 'cooldown';
+export interface PortalDefinition {
+    id: string;
+    type: PortalType;
+    width: number;
+    height: number;
+    depth: number;
+    shape: 'rectangle' | 'oval' | 'custom';
+    color: string;
+    emissiveColor: string;
+    particleEffect?: string;
+    soundEffect?: string;
+    activationTime: number;
+    cooldownTime: number;
+    requiresKey: boolean;
+    keyItemId?: string;
+}
+export interface Portal {
+    id: string;
+    definitionId: string;
+    name: string;
+    position: Vec3;
+    rotation: Quat;
+    state: PortalState;
+    active: boolean;
+    linkedPortalId: string | null;
+    destinationDimension: string | null;
+    destinationPosition: Vec3 | null;
+    entitiesInRange: Set<string>;
+    activationProgress: number;
+    lastUsedAt: number;
+    usageCount: number;
+    metadata: Record<string, unknown>;
+}
+export interface PortalLink {
+    portalA: string;
+    portalB: string;
+    bidirectional: boolean;
+    preserveVelocity: boolean;
+    preserveOrientation: boolean;
+}
+export interface Dimension {
+    id: string;
+    name: string;
+    description: string;
+    gravity: Vec3;
+    timeScale: number;
+    ambientColor: string;
+    fogDensity: number;
+    musicTrack?: string;
+    weatherType?: string;
+    spawnPoints: Vec3[];
+    isDefault: boolean;
+}
+export interface TeleportRequest {
+    entityId: string;
+    sourcePortalId: string;
+    targetPortalId: string | null;
+    targetPosition: Vec3 | null;
+    targetDimension: string | null;
+    velocity: Vec3;
+    orientation: Quat;
+}
+export interface TeleportResult {
+    success: boolean;
+    entityId: string;
+    startPosition: Vec3;
+    endPosition: Vec3;
+    startDimension: string;
+    endDimension: string;
+    duration: number;
+    reason?: string;
+}
+export type PortalEventType = 'portal-created' | 'portal-destroyed' | 'portal-activated' | 'portal-deactivated' | 'portal-enter' | 'portal-exit' | 'teleport-start' | 'teleport-complete' | 'teleport-failed' | 'dimension-enter' | 'dimension-exit' | 'link-created' | 'link-removed';
+export interface PortalEvent {
+    type: PortalEventType;
+    timestamp: number;
+    data: unknown;
+}
+export type PortalEventCallback = (event: PortalEvent) => void;
+export interface PortalConfig {
+    /** Maximum portals */
+    maxPortals: number;
+    /** Default activation range */
+    activationRange: number;
+    /** Default teleport range */
+    teleportRange: number;
+    /** Cooldown between uses */
+    cooldownTime: number;
+    /** Transition duration */
+    transitionDuration: number;
+    /** Current dimension */
+    currentDimension: string;
+    /** Allow cross-dimension portals */
+    allowCrossDimension: boolean;
+}
+export declare const DEFAULT_PORTAL_CONFIG: PortalConfig;
+export declare const DEFAULT_PORTAL_DEFINITIONS: PortalDefinition[];
+export declare const DEFAULT_DIMENSIONS: Dimension[];
+export declare class NicePortal {
+    private config;
+    private definitions;
+    private portals;
+    private links;
+    private dimensions;
+    private eventListeners;
+    private nextPortalId;
+    constructor(config?: Partial<PortalConfig>);
+    on(event: PortalEventType, callback: PortalEventCallback): () => void;
+    private emit;
+    registerDefinition(definition: PortalDefinition): void;
+    getDefinition(id: string): PortalDefinition | undefined;
+    registerDimension(dimension: Dimension): void;
+    getDimension(id: string): Dimension | undefined;
+    getAllDimensions(): Dimension[];
+    getCurrentDimension(): Dimension | undefined;
+    setCurrentDimension(dimensionId: string): boolean;
+    createPortal(definitionId: string, position: Vec3, rotation?: Quat, options?: {
+        name?: string;
+        linkedPortalId?: string;
+        destinationDimension?: string;
+        destinationPosition?: Vec3;
+        metadata?: Record<string, unknown>;
+    }): string | null;
+    destroyPortal(portalId: string): void;
+    link(portalAId: string, portalBId: string, options?: {
+        bidirectional?: boolean;
+        preserveVelocity?: boolean;
+        preserveOrientation?: boolean;
+    }): string | null;
+    unlink(linkId: string): void;
+    getLink(linkId: string): PortalLink | undefined;
+    activate(portalId: string): boolean;
+    private completeActivation;
+    deactivate(portalId: string): void;
+    checkEntityProximity(entityId: string, entityPosition: Vec3): void;
+    private tryTeleport;
+    teleportEntity(entityId: string, targetPosition: Vec3, targetDimension?: string): TeleportResult;
+    update(deltaTime: number): void;
+    getPortal(id: string): Portal | undefined;
+    getAllPortals(): Portal[];
+    getActivePortals(): Portal[];
+    getPortalsByDimension(dimensionId: string): Portal[];
+    getNearbyPortals(position: Vec3, radius: number): Portal[];
+    getConnectedPortal(portalId: string): Portal | undefined;
+    isPortalActive(portalId: string): boolean;
+    getPortalRenderInfo(portalId: string): {
+        position: Vec3;
+        rotation: Quat;
+        size: {
+            width: number;
+            height: number;
+        };
+        color: string;
+        emissiveColor: string;
+        activationProgress: number;
+        linkedView?: {
+            position: Vec3;
+            rotation: Quat;
+        };
+    } | null;
+    private vec3Distance;
+    private generateId;
+    destroy(): void;
+}
+export declare function createPortalSystem(config?: Partial<PortalConfig>): NicePortal;