@nice2dev/game-engine 1.3.12 → 1.3.14

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

@@ -1,158 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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;