@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/unity-integration/UnityLiveLink.d.ts

@@ -0,0 +1,350 @@
+/**
+ * @file UnityLiveLink.ts
+ * @description Unity Live Link system for real-time editor synchronization
+ * PRO-1.8.2: Unity Live Link
+ *
+ * Features:
+ * - Unity Editor Plugin (C#) integration
+ * - Bidirectional Sync Protocol (WebSocket)
+ * - Unity Play Mode Integration
+ * - Real-time scene sync
+ * - Selection mirroring
+ * - Property change streaming
+ */
+export type LiveLinkConnectionState = 'disconnected' | 'connecting' | 'connected' | 'authenticating' | 'syncing' | 'error';
+export type LiveLinkSyncDirection = 'toUnity' | 'fromUnity' | 'bidirectional';
+export type LiveLinkMessageType = 'handshake' | 'handshake_ack' | 'sync_scene' | 'sync_object' | 'sync_property' | 'selection_change' | 'create_object' | 'delete_object' | 'reparent_object' | 'play_mode_start' | 'play_mode_stop' | 'play_mode_pause' | 'play_mode_state' | 'hot_reload' | 'breakpoint_hit' | 'error' | 'ping' | 'pong';
+export type UnityPlayModeState = 'stopped' | 'playing' | 'paused';
+export type ConflictResolutionStrategy = 'unityWins' | 'nice2devWins' | 'lastWriteWins' | 'manual';
+export interface LiveLinkMessage {
+    /** Message type */
+    type: LiveLinkMessageType;
+    /** Sequence number for ordering */
+    sequence: number;
+    /** Timestamp */
+    timestamp: number;
+    /** Optional correlation ID for request/response */
+    correlationId?: string;
+    /** Payload */
+    payload: unknown;
+}
+export interface HandshakePayload {
+    /** Client name */
+    clientName: string;
+    /** Client version */
+    clientVersion: string;
+    /** Protocol version */
+    protocolVersion: number;
+    /** Supported features */
+    features: string[];
+    /** Unity project path */
+    projectPath?: string;
+    /** Unity version */
+    unityVersion?: string;
+}
+export interface HandshakeAckPayload {
+    /** Success flag */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Session ID */
+    sessionId: string;
+    /** Server features */
+    serverFeatures: string[];
+    /** Sync configuration */
+    syncConfig: LiveLinkSyncConfig;
+}
+export interface SyncScenePayload {
+    /** Scene name */
+    sceneName: string;
+    /** Scene path */
+    scenePath: string;
+    /** Scene GUID */
+    sceneGUID: string;
+    /** Root objects */
+    roots: SyncObjectPayload[];
+    /** Is full sync or delta */
+    isFullSync: boolean;
+    /** Version vector for conflict detection */
+    versionVector: Record<string, number>;
+}
+export interface SyncObjectPayload {
+    /** Instance ID (Unity's unique identifier per session) */
+    instanceId: number;
+    /** GUID (persistent identifier) */
+    guid?: string;
+    /** File ID within scene/prefab */
+    fileId?: number;
+    /** Object name */
+    name: string;
+    /** Is active */
+    isActive: boolean;
+    /** Layer */
+    layer: number;
+    /** Tag */
+    tag: string;
+    /** Transform data */
+    transform: {
+        localPosition: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        localRotation: {
+            x: number;
+            y: number;
+            z: number;
+            w: number;
+        };
+        localScale: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    /** Components */
+    components: SyncComponentPayload[];
+    /** Children instance IDs */
+    children: number[];
+    /** Version for conflict detection */
+    version: number;
+}
+export interface SyncComponentPayload {
+    /** Component instance ID */
+    instanceId: number;
+    /** Component type name */
+    typeName: string;
+    /** Component GUID (for scripts) */
+    scriptGUID?: string;
+    /** Is enabled */
+    enabled: boolean;
+    /** Serialized properties */
+    properties: Record<string, unknown>;
+    /** Version */
+    version: number;
+}
+export interface SyncPropertyPayload {
+    /** Target object instance ID */
+    objectInstanceId: number;
+    /** Component instance ID (0 for GameObject properties) */
+    componentInstanceId: number;
+    /** Property path */
+    propertyPath: string;
+    /** New value */
+    value: unknown;
+    /** Previous value (for conflict detection) */
+    previousValue?: unknown;
+    /** Version */
+    version: number;
+}
+export interface SelectionChangePayload {
+    /** Selected object instance IDs */
+    selectedInstanceIds: number[];
+    /** Active object instance ID */
+    activeInstanceId: number | null;
+    /** Selection origin ('unity' or 'nice2dev') */
+    origin: string;
+}
+export interface CreateObjectPayload {
+    /** Parent instance ID (-1 for root) */
+    parentInstanceId: number;
+    /** Object data */
+    object: SyncObjectPayload;
+    /** Position in parent's children list */
+    siblingIndex: number;
+}
+export interface DeleteObjectPayload {
+    /** Instance IDs to delete */
+    instanceIds: number[];
+    /** Delete children too */
+    deleteChildren: boolean;
+}
+export interface ReparentObjectPayload {
+    /** Object instance ID */
+    instanceId: number;
+    /** New parent instance ID (-1 for root) */
+    newParentInstanceId: number;
+    /** New sibling index */
+    newSiblingIndex: number;
+}
+export interface PlayModeStatePayload {
+    /** Current state */
+    state: UnityPlayModeState;
+    /** Game time */
+    gameTime: number;
+    /** Frame count */
+    frameCount: number;
+    /** Target frame rate */
+    targetFrameRate: number;
+    /** Actual FPS */
+    actualFps: number;
+}
+export interface HotReloadPayload {
+    /** Scripts that were reloaded */
+    reloadedScripts: string[];
+    /** Compile errors */
+    errors: Array<{
+        script: string;
+        line: number;
+        column: number;
+        message: string;
+    }>;
+    /** Success */
+    success: boolean;
+}
+export interface BreakpointPayload {
+    /** Script GUID */
+    scriptGUID: string;
+    /** Script path */
+    scriptPath: string;
+    /** Line number */
+    line: number;
+    /** Object instance ID where breakpoint hit */
+    objectInstanceId?: number;
+    /** Call stack */
+    callStack: Array<{
+        method: string;
+        file: string;
+        line: number;
+    }>;
+    /** Local variables */
+    locals: Record<string, unknown>;
+}
+export interface LiveLinkSyncConfig {
+    /** Sync direction */
+    direction: LiveLinkSyncDirection;
+    /** Conflict resolution */
+    conflictResolution: ConflictResolutionStrategy;
+    /** Auto-sync enabled */
+    autoSync: boolean;
+    /** Sync interval (ms) for auto-sync */
+    syncInterval: number;
+    /** Components to sync (empty = all) */
+    componentFilter: string[];
+    /** Layers to sync (empty = all) */
+    layerFilter: number[];
+    /** Max pending changes before forced sync */
+    maxPendingChanges: number;
+}
+export interface LiveLinkClientConfig {
+    /** WebSocket URL */
+    serverUrl: string;
+    /** Auto-reconnect */
+    autoReconnect: boolean;
+    /** Reconnect interval (ms) */
+    reconnectInterval: number;
+    /** Max reconnect attempts */
+    maxReconnectAttempts: number;
+    /** Heartbeat interval (ms) */
+    heartbeatInterval: number;
+    /** Connection timeout (ms) */
+    connectionTimeout: number;
+    /** Sync configuration */
+    syncConfig: LiveLinkSyncConfig;
+}
+export declare class UnityLiveLinkClient {
+    private config;
+    private ws;
+    private state;
+    private sessionId;
+    private sequence;
+    private reconnectAttempts;
+    private heartbeatTimer;
+    private reconnectTimer;
+    private pendingRequests;
+    private callbacks;
+    private sceneData;
+    private selectedIds;
+    private activeId;
+    private versionVector;
+    private pendingChanges;
+    private playModeState;
+    constructor(config?: Partial<LiveLinkClientConfig>);
+    connect(): Promise<void>;
+    disconnect(): void;
+    private handleDisconnect;
+    private scheduleReconnect;
+    private stopReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private handleMessage;
+    private handleHandshakeAck;
+    private handleSyncScene;
+    private processObjectRecursive;
+    private handleSyncObject;
+    private handleSyncProperty;
+    private applyPropertyChange;
+    private handleSelectionChange;
+    private handleCreateObject;
+    private handleDeleteObject;
+    private deleteObjectAndChildren;
+    private handleReparentObject;
+    private handlePlayModeChange;
+    private handlePlayModeState;
+    private handleHotReload;
+    private handleBreakpoint;
+    private handleError;
+    private send;
+    private sendRequest;
+    private clearPendingRequests;
+    private generateCorrelationId;
+    private sendHandshake;
+    private sendPing;
+    getState(): LiveLinkConnectionState;
+    isConnected(): boolean;
+    getSessionId(): string;
+    getPlayModeState(): UnityPlayModeState;
+    getSceneData(): Map<number, SyncObjectPayload>;
+    getObject(instanceId: number): SyncObjectPayload | undefined;
+    getSelectedIds(): number[];
+    getActiveId(): number | null;
+    requestFullSync(): void;
+    setSelection(instanceIds: number[], activeId?: number | null): void;
+    updateProperty(objectInstanceId: number, componentInstanceId: number, propertyPath: string, value: unknown): void;
+    flushPendingChanges(): void;
+    createObject(parentInstanceId: number, name: string, position?: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    deleteObjects(instanceIds: number[], deleteChildren?: boolean): void;
+    reparentObject(instanceId: number, newParentInstanceId: number, siblingIndex?: number): void;
+    enterPlayMode(): void;
+    exitPlayMode(): void;
+    pausePlayMode(): void;
+    togglePlayMode(): void;
+    triggerHotReload(scriptPaths?: string[]): void;
+    setCallbacks(callbacks: LiveLinkCallbacks): void;
+    onStateChange(callback: (state: LiveLinkConnectionState) => void): () => void;
+    onConnected(callback: (sessionId: string) => void): () => void;
+    onDisconnected(callback: (code: number, reason: string) => void): () => void;
+    onSceneSync(callback: (scene: SyncScenePayload) => void): () => void;
+}
+export interface LiveLinkCallbacks {
+    onStateChange?: (state: LiveLinkConnectionState) => void;
+    onConnected?: (sessionId: string) => void;
+    onDisconnected?: (code: number, reason: string) => void;
+    onReconnecting?: (attempt: number) => void;
+    onError?: (error: Error) => void;
+    onSceneSync?: (scene: SyncScenePayload) => void;
+    onObjectSync?: (object: SyncObjectPayload) => void;
+    onPropertySync?: (property: SyncPropertyPayload) => void;
+    onSelectionChange?: (selection: SelectionChangePayload) => void;
+    onObjectCreated?: (payload: CreateObjectPayload) => void;
+    onObjectDeleted?: (payload: DeleteObjectPayload) => void;
+    onObjectReparented?: (payload: ReparentObjectPayload) => void;
+    onConflict?: (type: string, id: number, local: unknown, remote: unknown) => void;
+    onPlayModeStart?: (state: PlayModeStatePayload) => void;
+    onPlayModeStop?: (state: PlayModeStatePayload) => void;
+    onPlayModePause?: (state: PlayModeStatePayload) => void;
+    onPlayModeState?: (state: PlayModeStatePayload) => void;
+    onHotReload?: (result: HotReloadPayload) => void;
+    onBreakpointHit?: (breakpoint: BreakpointPayload) => void;
+}
+export declare function generateUnityLiveLinkPlugin(config?: {
+    namespace?: string;
+    className?: string;
+    defaultPort?: number;
+}): string;
+export declare function createUnityLiveLinkClient(config?: Partial<LiveLinkClientConfig>): UnityLiveLinkClient;
+export declare function createDefaultLiveLinkConfig(): LiveLinkClientConfig;

package/dist/types/unity-integration/components/UnityAssetStoreBrowser.d.ts

@@ -0,0 +1,67 @@
+import React from 'react';
+export interface AssetStoreAsset {
+    id: string;
+    name: string;
+    publisher: string;
+    publisherId: string;
+    category: 'all' | '3d' | '2d' | 'tools' | 'vfx' | 'audio' | 'templates' | 'add-ons';
+    shortDescription: string;
+    description: string;
+    price: number;
+    originalPrice?: number;
+    currency: string;
+    isFree: boolean;
+    rating: number;
+    ratingCount: number;
+    thumbnailUrl: string;
+    previewImages: string[];
+    unityVersions: string[];
+    minUnityVersion: string;
+    fileSize: number;
+    lastUpdated: string;
+    version: string;
+    tags: string[];
+    isOwned: boolean;
+    renderPipelines: ('builtin' | 'urp' | 'hdrp')[];
+    url: string;
+}
+export interface AssetSearchQuery {
+    query: string;
+    category: AssetStoreAsset['category'];
+    pricing: 'all' | 'free' | 'paid' | 'sale';
+    minRating: number;
+    sortBy: 'relevance' | 'popularity' | 'rating' | 'price_asc' | 'price_desc' | 'newest';
+    page: number;
+    pageSize: number;
+}
+export interface AssetStoreTheme {
+    background: string;
+    surfaceBackground: string;
+    cardBackground: string;
+    headerBackground: string;
+    textPrimary: string;
+    textSecondary: string;
+    accent: string;
+    success: string;
+    warning: string;
+    danger: string;
+    star: string;
+    border: string;
+    freeBadge: string;
+    ownedBadge: string;
+    saleBadge: string;
+}
+export interface UnityAssetStoreBrowserProps {
+    theme?: Partial<AssetStoreTheme>;
+    onDownload?: (assetId: string) => Promise<void>;
+    onPurchase?: (assetIds: string[]) => Promise<void>;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface UnityAssetStoreBrowserRef {
+    search: (query?: string) => Promise<void>;
+    getCart: () => string[];
+    clearCart: () => void;
+}
+export declare const UnityAssetStoreBrowser: React.ForwardRefExoticComponent<UnityAssetStoreBrowserProps & React.RefAttributes<UnityAssetStoreBrowserRef>>;
+export default UnityAssetStoreBrowser;

package/dist/types/unity-integration/components/UnityProjectBrowser.d.ts

@@ -0,0 +1,90 @@
+import React from 'react';
+export interface UnityProjectAsset {
+    id: string;
+    name: string;
+    path: string;
+    type: 'scene' | 'prefab' | 'material' | 'texture' | 'mesh' | 'animation' | 'script' | 'audio' | 'other';
+    guid: string;
+    size: number;
+    lastModified: string;
+    meta?: Record<string, unknown>;
+    dependencies?: string[];
+    thumbnail?: string;
+    selected: boolean;
+}
+export interface UnityProjectFolder {
+    path: string;
+    name: string;
+    children: (UnityProjectFolder | UnityProjectAsset)[];
+    expanded: boolean;
+}
+export interface UnityProjectInfo {
+    name: string;
+    path: string;
+    unityVersion: string;
+    renderPipeline: 'builtin' | 'urp' | 'hdrp' | 'custom';
+    scriptingBackend: 'mono' | 'il2cpp';
+    apiCompatibility: 'NET_Standard_2_0' | 'NET_4_6' | 'NET_Standard_2_1';
+    assets: UnityProjectAsset[];
+    folders: UnityProjectFolder;
+    packages: Array<{
+        name: string;
+        version: string;
+        source: string;
+    }>;
+    scenes: Array<{
+        path: string;
+        enabled: boolean;
+    }>;
+}
+export interface ImportProgress {
+    phase: 'scanning' | 'analyzing' | 'converting' | 'importing' | 'complete' | 'error';
+    current: number;
+    total: number;
+    currentAsset: string;
+    message: string;
+}
+export interface LiveLinkStatus {
+    connected: boolean;
+    unityVersion?: string;
+    projectName?: string;
+    playMode: 'stopped' | 'playing' | 'paused';
+    lastSync?: string;
+}
+export interface UnityProjectBrowserTheme {
+    background: string;
+    panelBackground: string;
+    headerBackground: string;
+    itemBackground: string;
+    itemHover: string;
+    itemSelected: string;
+    textPrimary: string;
+    textSecondary: string;
+    accent: string;
+    success: string;
+    warning: string;
+    danger: string;
+    border: string;
+    folderColor: string;
+    sceneColor: string;
+    prefabColor: string;
+    materialColor: string;
+    scriptColor: string;
+}
+export interface UnityProjectBrowserProps {
+    projectPath?: string;
+    theme?: Partial<UnityProjectBrowserTheme>;
+    onProjectLoad?: (info: UnityProjectInfo) => void;
+    onImport?: (assets: UnityProjectAsset[]) => Promise<void>;
+    onLiveLinkConnect?: () => Promise<LiveLinkStatus>;
+    onLiveLinkDisconnect?: () => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface UnityProjectBrowserRef {
+    loadProject: (path: string) => Promise<void>;
+    getSelectedAssets: () => UnityProjectAsset[];
+    importSelected: () => Promise<void>;
+}
+export declare const UnityProjectBrowser: React.ForwardRefExoticComponent<UnityProjectBrowserProps & React.RefAttributes<UnityProjectBrowserRef>>;
+export default UnityProjectBrowser;

package/dist/types/unity-integration/components/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Unity Integration UI Components
+ * PRO-1.8: Unity Engine Deep Integration
+ */
+export { UnityProjectBrowser } from './UnityProjectBrowser';
+export type { UnityProjectBrowserProps, UnityProjectBrowserRef, UnityProjectBrowserTheme, UnityProjectAsset, UnityProjectFolder, UnityProjectInfo, ImportProgress, LiveLinkStatus, } from './UnityProjectBrowser';
+export { UnityAssetStoreBrowser } from './UnityAssetStoreBrowser';
+export type { UnityAssetStoreBrowserProps, UnityAssetStoreBrowserRef, AssetStoreTheme, AssetStoreAsset, AssetSearchQuery, } from './UnityAssetStoreBrowser';

package/dist/types/unity-integration/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @file index.ts
+ * @description Unity Integration Module Exports
+ * PRO-1.8: Unity Engine Deep Integration
+ */
+export { type UnityYAMLDocument, type UnityMetaFile, type UnityScene, type UnityPrefab, type UnityGameObjectData, type UnityComponentType, type UnityTransformData, type UnityScriptInfo, type UnityMaterialInfo, type UnityAnimationClipInfo, type UnityAnimationCurve, type UnityAnimationEvent, type UnitySceneInfo, type UnityPrefabInfo, type UnityProjectInfo, type UnityImportCallbacks, type UnityGUID, type UnityAssetType, type UnityAssetInfo, parseUnityYAML, parseUnityMeta, getUnityClassName, UnityProjectImporter, createUnityProjectImporter, } from './UnityImport';
+export { type LiveLinkMessageType, type LiveLinkMessage, type LiveLinkConnectionState, type LiveLinkSyncDirection, type UnityPlayModeState, type ConflictResolutionStrategy, type SyncScenePayload, type SyncObjectPayload, type SyncPropertyPayload, type SyncComponentPayload, type SelectionChangePayload, type PlayModeStatePayload, type HandshakePayload, type HandshakeAckPayload, type LiveLinkSyncConfig, type LiveLinkClientConfig, type LiveLinkCallbacks, UnityLiveLinkClient, generateUnityLiveLinkPlugin, createUnityLiveLinkClient, createDefaultLiveLinkConfig, } from './UnityLiveLink';
+export { type AssetStoreCategory, type AssetStorePricing, type AssetStoreRating, type PackageSource, type PackageResolutionType, type AssetStoreAsset, type AssetStoreSearchQuery, type AssetStoreSearchResult, type AssetStoreReview, type UPMPackage, type PackageSample, type PackageManifest, type ScopedRegistry, type PackageLock, type PackageLockEntry, type AssetStoreBrowserConfig, type AssetStoreUser, type AssetDownloadInfo, type ImportOptions, type ImportResult, type InstallResult, type UninstallResult, type AssetStoreCallbacks, type PackageManagerCallbacks, AssetStoreBrowser, UnityPackageManager, createAssetStoreBrowser, createUnityPackageManager, } from './UnityAssetStore';
+export * from './components';