@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,422 @@
+/**
+ * NiceCloud - Cloud Save & Sync System
+ *
+ * Comprehensive cloud storage system for save games, settings,
+ * and player data synchronization across devices.
+ *
+ * Features:
+ * - Cloud save management
+ * - Auto-sync
+ * - Conflict resolution
+ * - Offline support
+ * - Data compression
+ * - Encryption
+ * - Version control
+ * - Selective sync
+ * - Bandwidth management
+ * - Progress tracking
+ * - Multi-device support
+ * - Backup & restore
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+/** Unique save ID */
+export type SaveId = string;
+/** Unique device ID */
+export type DeviceId = string;
+/** Sync state */
+export type SyncState = 'idle' | 'syncing' | 'uploading' | 'downloading' | 'error' | 'offline' | 'conflict';
+/** Conflict resolution strategy */
+export type ConflictResolution = 'local_wins' | 'remote_wins' | 'newest_wins' | 'merge' | 'manual';
+/** Save type */
+export type SaveType = 'auto' | 'manual' | 'checkpoint' | 'quicksave' | 'settings' | 'profile' | 'custom';
+/** Save metadata */
+export interface SaveMetadata {
+    id: SaveId;
+    name: string;
+    type: SaveType;
+    version: number;
+    size: number;
+    compressed: boolean;
+    encrypted: boolean;
+    checksum: string;
+    createdAt: number;
+    modifiedAt: number;
+    uploadedAt?: number;
+    deviceId: DeviceId;
+    deviceName: string;
+    gameVersion: string;
+    playtime?: number;
+    level?: number;
+    location?: string;
+    screenshot?: string;
+    tags?: string[];
+    customData?: Record<string, unknown>;
+}
+/** Cloud save data */
+export interface CloudSave {
+    metadata: SaveMetadata;
+    data: unknown;
+    localPath?: string;
+    cloudPath?: string;
+    syncStatus: 'synced' | 'pending_upload' | 'pending_download' | 'conflict' | 'local_only';
+    lastSyncTime?: number;
+}
+/** Sync conflict */
+export interface SyncConflict {
+    saveId: SaveId;
+    localSave: CloudSave;
+    remoteSave: CloudSave;
+    detectedAt: number;
+    resolved: boolean;
+    resolution?: ConflictResolution;
+}
+/** Sync progress */
+export interface SyncProgress {
+    operation: 'upload' | 'download';
+    saveId: SaveId;
+    bytesTransferred: number;
+    totalBytes: number;
+    percentage: number;
+    startedAt: number;
+    estimatedTime?: number;
+}
+/** Device info */
+export interface DeviceInfo {
+    id: DeviceId;
+    name: string;
+    platform: string;
+    lastSeen: number;
+    lastSyncTime?: number;
+    isCurrentDevice: boolean;
+}
+/** Quota info */
+export interface QuotaInfo {
+    used: number;
+    total: number;
+    remaining: number;
+    percentage: number;
+    saveCount: number;
+    maxSaves?: number;
+}
+/** Sync options */
+export interface SyncOptions {
+    force?: boolean;
+    selective?: SaveId[];
+    conflictResolution?: ConflictResolution;
+    compress?: boolean;
+    encrypt?: boolean;
+    priority?: 'low' | 'normal' | 'high';
+    timeout?: number;
+}
+/** Upload options */
+export interface UploadOptions extends SyncOptions {
+    overwrite?: boolean;
+    screenshot?: string;
+    tags?: string[];
+}
+/** Download options */
+export interface DownloadOptions extends SyncOptions {
+    createBackup?: boolean;
+}
+/** Cloud provider interface */
+export interface CloudProvider {
+    name: string;
+    isAuthenticated: () => Promise<boolean>;
+    authenticate: () => Promise<boolean>;
+    logout: () => Promise<void>;
+    listSaves: () => Promise<SaveMetadata[]>;
+    uploadSave: (save: CloudSave, options?: UploadOptions) => Promise<boolean>;
+    downloadSave: (saveId: SaveId, options?: DownloadOptions) => Promise<CloudSave | undefined>;
+    deleteSave: (saveId: SaveId) => Promise<boolean>;
+    getQuota: () => Promise<QuotaInfo>;
+    onProgress?: (progress: SyncProgress) => void;
+}
+/** Backup info */
+export interface BackupInfo {
+    id: string;
+    saveId: SaveId;
+    timestamp: number;
+    size: number;
+    compressed: boolean;
+    data?: unknown;
+}
+/** Cloud statistics */
+export interface CloudStatistics {
+    totalUploads: number;
+    totalDownloads: number;
+    bytesUploaded: number;
+    bytesDownloaded: number;
+    conflictsResolved: number;
+    lastSyncTime?: number;
+    syncErrors: number;
+    offlineSaves: number;
+}
+/** Encryption key info */
+export interface EncryptionKeyInfo {
+    id: string;
+    algorithm: string;
+    createdAt: number;
+}
+/** Cloud event types */
+export type CloudEventType = 'sync_started' | 'sync_completed' | 'sync_failed' | 'upload_started' | 'upload_progress' | 'upload_completed' | 'upload_failed' | 'download_started' | 'download_progress' | 'download_completed' | 'download_failed' | 'conflict_detected' | 'conflict_resolved' | 'save_created' | 'save_deleted' | 'quota_warning' | 'offline_mode' | 'online_mode' | 'auth_required';
+/** Cloud event data */
+export interface CloudEvent {
+    type: CloudEventType;
+    timestamp: number;
+    saveId?: SaveId;
+    data?: unknown;
+    error?: string;
+}
+/** Cloud event callback */
+export type CloudEventCallback = (event: CloudEvent) => void;
+/** Cloud system configuration */
+export interface CloudConfig {
+    autoSync: boolean;
+    autoSyncInterval: number;
+    syncOnSave: boolean;
+    syncOnLoad: boolean;
+    offlineSupport: boolean;
+    compressionEnabled: boolean;
+    compressionThreshold: number;
+    encryptionEnabled: boolean;
+    conflictResolution: ConflictResolution;
+    maxBackups: number;
+    retryAttempts: number;
+    retryDelay: number;
+    quotaWarningThreshold: number;
+    timeoutMs: number;
+}
+/** Default configuration */
+export declare const DEFAULT_CLOUD_CONFIG: CloudConfig;
+/**
+ * Cloud save and sync system
+ */
+export declare class NiceCloud extends EventEmitter {
+    private config;
+    private provider?;
+    private saves;
+    private conflicts;
+    private backups;
+    private devices;
+    private currentDeviceId;
+    private currentDeviceName;
+    private syncState;
+    private isOnline;
+    private syncQueue;
+    private syncInterval?;
+    private statistics;
+    private encryptionKey?;
+    private pendingOperations;
+    constructor(config?: Partial<CloudConfig>);
+    /**
+     * Emit cloud event
+     */
+    private emitEvent;
+    /**
+     * Generate device ID
+     */
+    private generateDeviceId;
+    /**
+     * Get device name
+     */
+    private getDeviceName;
+    /**
+     * Setup network listener
+     */
+    private setupNetworkListener;
+    /**
+     * Load local state
+     */
+    private loadLocalState;
+    /**
+     * Save local state
+     */
+    private saveLocalState;
+    /**
+     * Set cloud provider
+     */
+    setProvider(provider: CloudProvider): void;
+    /**
+     * Get provider
+     */
+    getProvider(): CloudProvider | undefined;
+    /**
+     * Check authentication
+     */
+    isAuthenticated(): Promise<boolean>;
+    /**
+     * Authenticate
+     */
+    authenticate(): Promise<boolean>;
+    /**
+     * Logout
+     */
+    logout(): Promise<void>;
+    /**
+     * Start auto sync
+     */
+    startAutoSync(): void;
+    /**
+     * Stop auto sync
+     */
+    stopAutoSync(): void;
+    /**
+     * Full sync
+     */
+    sync(options?: SyncOptions): Promise<boolean>;
+    /**
+     * Sync pending saves (after coming online)
+     */
+    private syncPendingSaves;
+    /**
+     * Create cloud save
+     */
+    createSave(name: string, data: unknown, type?: SaveType, options?: UploadOptions): Promise<CloudSave | undefined>;
+    /**
+     * Update save
+     */
+    updateSave(saveId: SaveId, data: unknown, options?: UploadOptions): Promise<boolean>;
+    /**
+     * Upload save to cloud
+     */
+    uploadSave(saveId: SaveId, options?: UploadOptions): Promise<boolean>;
+    /**
+     * Perform upload with retries
+     */
+    private performUpload;
+    /**
+     * Download save from cloud
+     */
+    downloadSave(saveId: SaveId, options?: DownloadOptions): Promise<CloudSave | undefined>;
+    /**
+     * Delete save
+     */
+    deleteSave(saveId: SaveId, deleteFromCloud?: boolean): Promise<boolean>;
+    /**
+     * Get save
+     */
+    getSave(saveId: SaveId): CloudSave | undefined;
+    /**
+     * Get all saves
+     */
+    getAllSaves(type?: SaveType): CloudSave[];
+    /**
+     * List cloud saves
+     */
+    listCloudSaves(): Promise<SaveMetadata[]>;
+    /**
+     * Handle conflict
+     */
+    handleConflict(saveId: SaveId, resolution?: ConflictResolution): Promise<boolean>;
+    /**
+     * Resolve conflict
+     */
+    resolveConflict(saveId: SaveId, resolution: ConflictResolution): Promise<boolean>;
+    /**
+     * Merge saves (simple merge strategy)
+     */
+    private mergeSaves;
+    /**
+     * Get conflicts
+     */
+    getConflicts(): SyncConflict[];
+    /**
+     * Create backup
+     */
+    createBackup(saveId: SaveId): Promise<BackupInfo | undefined>;
+    /**
+     * Restore from backup
+     */
+    restoreBackup(saveId: SaveId, backupId: string): Promise<boolean>;
+    /**
+     * Get backups for save
+     */
+    getBackups(saveId: SaveId): BackupInfo[];
+    /**
+     * Get quota info
+     */
+    getQuota(): Promise<QuotaInfo | undefined>;
+    /**
+     * Check quota and warn if necessary
+     */
+    private checkQuota;
+    /**
+     * Set encryption key
+     */
+    setEncryptionKey(password: string): Promise<void>;
+    /**
+     * Encrypt data
+     */
+    private encrypt;
+    /**
+     * Decrypt data
+     */
+    private decrypt;
+    /**
+     * Compress data
+     */
+    private compress;
+    /**
+     * Decompress data
+     */
+    private decompress;
+    /**
+     * Calculate size
+     */
+    private calculateSize;
+    /**
+     * Calculate checksum
+     */
+    private calculateChecksum;
+    /**
+     * Create timeout promise
+     */
+    private createTimeout;
+    /**
+     * Delay helper
+     */
+    private delay;
+    /**
+     * Schedule retry
+     */
+    private scheduleRetry;
+    /**
+     * Load from storage
+     */
+    private loadFromStorage;
+    /**
+     * Save to storage
+     */
+    private saveToStorage;
+    /**
+     * Get sync state
+     */
+    getSyncState(): SyncState;
+    /**
+     * Is online
+     */
+    isOnlineStatus(): boolean;
+    /**
+     * Get statistics
+     */
+    getStatistics(): CloudStatistics;
+    /**
+     * Get devices
+     */
+    getDevices(): DeviceInfo[];
+    /**
+     * Get current device ID
+     */
+    getCurrentDeviceId(): DeviceId;
+    /**
+     * Destroy cloud system
+     */
+    destroy(): void;
+}
+/**
+ * Create cloud system instance
+ */
+export declare function createCloudSystem(config?: Partial<CloudConfig>): NiceCloud;
+export default NiceCloud;

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

@@ -0,0 +1,238 @@
+/**
+ * NiceCollision - Game Engine Collision Detection System
+ *
+ * Comprehensive collision detection supporting:
+ * - AABB, Circle, OBB, Polygon colliders
+ * - Spatial partitioning (Grid, QuadTree)
+ * - Broad phase + Narrow phase detection
+ * - Collision layers and masks
+ * - Trigger vs solid collisions
+ * - Raycasting and shape casting
+ * - Collision manifolds with contact points
+ * - Continuous collision detection (CCD)
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+export type ColliderId = string;
+export type LayerId = number;
+export type BodyId = string;
+export type ColliderType = 'aabb' | 'circle' | 'obb' | 'polygon' | 'capsule';
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface AABB {
+    type: 'aabb';
+    min: Vec2;
+    max: Vec2;
+}
+export interface Circle {
+    type: 'circle';
+    center: Vec2;
+    radius: number;
+}
+export interface OBB {
+    type: 'obb';
+    center: Vec2;
+    halfExtents: Vec2;
+    rotation: number;
+}
+export interface Polygon {
+    type: 'polygon';
+    vertices: Vec2[];
+    center?: Vec2;
+}
+export interface Capsule {
+    type: 'capsule';
+    start: Vec2;
+    end: Vec2;
+    radius: number;
+}
+export type Shape = AABB | Circle | OBB | Polygon | Capsule;
+export interface Collider {
+    id: ColliderId;
+    bodyId: BodyId;
+    shape: Shape;
+    offset: Vec2;
+    isTrigger: boolean;
+    layer: LayerId;
+    mask: number;
+    userData?: unknown;
+    enabled: boolean;
+}
+export interface CollisionBody {
+    id: BodyId;
+    position: Vec2;
+    rotation: number;
+    velocity: Vec2;
+    colliders: ColliderId[];
+    isStatic: boolean;
+    userData?: unknown;
+    enabled: boolean;
+}
+export interface ContactPoint {
+    position: Vec2;
+    normal: Vec2;
+    penetration: number;
+}
+export interface CollisionManifold {
+    colliderA: ColliderId;
+    colliderB: ColliderId;
+    bodyA: BodyId;
+    bodyB: BodyId;
+    contacts: ContactPoint[];
+    normal: Vec2;
+    penetration: number;
+    isTrigger: boolean;
+}
+export interface RaycastHit {
+    colliderId: ColliderId;
+    bodyId: BodyId;
+    point: Vec2;
+    normal: Vec2;
+    distance: number;
+    fraction: number;
+}
+export interface ShapeCastHit extends RaycastHit {
+    shape: Shape;
+}
+export type SpatialStructure = 'none' | 'grid' | 'quadtree';
+export interface GridCell {
+    x: number;
+    y: number;
+    colliders: Set<ColliderId>;
+}
+export interface QuadTreeNode {
+    bounds: AABB;
+    colliders: Set<ColliderId>;
+    children?: QuadTreeNode[];
+    depth: number;
+}
+export type CollisionEventType = 'collision-enter' | 'collision-stay' | 'collision-exit' | 'trigger-enter' | 'trigger-stay' | 'trigger-exit';
+export interface CollisionEvent {
+    type: CollisionEventType;
+    manifold?: CollisionManifold;
+    colliderA: ColliderId;
+    colliderB: ColliderId;
+    bodyA: BodyId;
+    bodyB: BodyId;
+}
+export type CollisionEventCallback = (event: CollisionEvent) => void;
+export interface CollisionConfig {
+    spatialStructure: SpatialStructure;
+    gridCellSize: number;
+    quadTreeMaxDepth: number;
+    quadTreeMaxObjects: number;
+    worldBounds: AABB;
+    enableCCD: boolean;
+    ccdIterations: number;
+    maxCollisionPairs: number;
+}
+export declare const DEFAULT_COLLISION_CONFIG: CollisionConfig;
+export declare class NiceCollision extends EventEmitter {
+    private config;
+    private colliders;
+    private bodies;
+    private activeCollisions;
+    private previousCollisions;
+    private grid;
+    private quadTree;
+    private nextColliderId;
+    private nextBodyId;
+    private destroyed;
+    constructor(config?: Partial<CollisionConfig>);
+    private initializeSpatialStructure;
+    private createQuadTreeNode;
+    createBody(options?: {
+        position?: Vec2;
+        rotation?: number;
+        velocity?: Vec2;
+        isStatic?: boolean;
+        userData?: unknown;
+    }): BodyId;
+    getBody(bodyId: BodyId): CollisionBody | undefined;
+    removeBody(bodyId: BodyId): void;
+    setBodyPosition(bodyId: BodyId, position: Vec2): void;
+    setBodyRotation(bodyId: BodyId, rotation: number): void;
+    setBodyVelocity(bodyId: BodyId, velocity: Vec2): void;
+    setBodyEnabled(bodyId: BodyId, enabled: boolean): void;
+    private updateBodyColliders;
+    createCollider(bodyId: BodyId, shape: Shape, options?: {
+        offset?: Vec2;
+        isTrigger?: boolean;
+        layer?: LayerId;
+        mask?: number;
+        userData?: unknown;
+    }): ColliderId;
+    getCollider(colliderId: ColliderId): Collider | undefined;
+    removeCollider(colliderId: ColliderId): void;
+    setColliderEnabled(colliderId: ColliderId, enabled: boolean): void;
+    createAABB(width: number, height: number, centerOffset?: Vec2): AABB;
+    createCircle(radius: number, centerOffset?: Vec2): Circle;
+    createOBB(width: number, height: number, rotation?: number): OBB;
+    createPolygon(vertices: Vec2[]): Polygon;
+    createCapsule(length: number, radius: number): Capsule;
+    private getColliderWorldBounds;
+    private getWorldShape;
+    private getShapeBounds;
+    private getOBBCorners;
+    private insertIntoSpatialStructure;
+    private removeFromSpatialStructure;
+    private updateSpatialStructure;
+    private getCellKey;
+    private insertIntoGrid;
+    private removeFromGrid;
+    private insertIntoQuadTree;
+    private insertIntoQuadTreeNode;
+    private subdivideQuadTree;
+    private removeFromQuadTree;
+    private removeFromQuadTreeNode;
+    update(): CollisionManifold[];
+    private getPairKey;
+    private broadPhase;
+    private queryQuadTreePairs;
+    private shouldCheckPair;
+    private narrowPhase;
+    private testShapes;
+    private testAABBvsAABB;
+    private aabbIntersects;
+    private testCircleVsCircle;
+    private testAABBvsCircle;
+    private testOBBvsShape;
+    private testPolygonVsShape;
+    private testCapsuleVsShape;
+    private testCapsuleVsCapsule;
+    private testCapsuleVsCircle;
+    private closestPointOnSegment;
+    private closestPointsOnSegments;
+    private getShapeAxes;
+    private projectShape;
+    private getOverlap;
+    private getShapeCenter;
+    private emitCollisionEvents;
+    raycast(origin: Vec2, direction: Vec2, maxDistance?: number, layerMask?: number): RaycastHit[];
+    private raycastShape;
+    private raycastAABB;
+    private raycastCircle;
+    private raycastOBB;
+    private raycastPolygon;
+    private raycastSegment;
+    private raycastCapsule;
+    queryPoint(point: Vec2, layerMask?: number): ColliderId[];
+    private pointInShape;
+    private pointInPolygon;
+    queryAABB(aabb: AABB, layerMask?: number): ColliderId[];
+    queryCircle(center: Vec2, radius: number, layerMask?: number): ColliderId[];
+    getStats(): {
+        bodies: number;
+        colliders: number;
+        activeCollisions: number;
+        gridCells: number;
+    };
+    clear(): void;
+    on(event: 'collision', callback: CollisionEventCallback): this;
+    off(event: 'collision', callback: CollisionEventCallback): this;
+    destroy(): void;
+}
+export declare function createCollisionSystem(config?: Partial<CollisionConfig>): NiceCollision;