@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/editor/UndoRedoPro.d.ts

@@ -0,0 +1,228 @@
+/**
+ * @file UndoRedoPro.ts
+ * @description Advanced Undo/Redo system with selective undo, branch history, snapshots
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Command-based undo/redo
+ * - Selective undo (undo specific actions without undoing newer ones)
+ * - Branch history (fork history at any point)
+ * - Automatic snapshots
+ * - Manual snapshots (named save points)
+ * - Action grouping (combine multiple actions)
+ * - Action filtering by category/target
+ * - History visualization data
+ * - Memory management (limit history size)
+ * - Serialization for persistence
+ */
+export type ActionCategory = 'transform' | 'component' | 'entity' | 'scene' | 'asset' | 'selection' | 'property' | 'hierarchy' | 'material' | 'animation' | 'physics' | 'audio' | 'script' | 'prefab' | 'other';
+export interface UndoableAction {
+    id: string;
+    name: string;
+    description: string;
+    category: ActionCategory;
+    timestamp: number;
+    targetId?: string;
+    targetType?: string;
+    doData: unknown;
+    undoData: unknown;
+    actionType: string;
+    groupId?: string;
+    isGroupStart?: boolean;
+    isGroupEnd?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface ActionGroup {
+    id: string;
+    name: string;
+    description: string;
+    actionIds: string[];
+    timestamp: number;
+    isCollapsed: boolean;
+}
+export interface HistorySnapshot {
+    id: string;
+    name: string;
+    description: string;
+    timestamp: number;
+    actionIndex: number;
+    stateData: string;
+    isAutoSnapshot: boolean;
+    thumbnail?: string;
+}
+export interface HistoryBranch {
+    id: string;
+    name: string;
+    parentBranchId: string | null;
+    forkActionIndex: number;
+    actions: UndoableAction[];
+    currentIndex: number;
+    createdAt: number;
+    isActive: boolean;
+}
+export interface ActionExecutor {
+    execute(data: unknown): void;
+    undo(data: unknown): void;
+    validate?(data: unknown): boolean;
+    merge?(oldData: unknown, newData: unknown): unknown | null;
+}
+export interface UndoRedoConfig {
+    maxHistorySize: number;
+    maxBranches: number;
+    autoSnapshotInterval: number;
+    autoSnapshotOnBranch: boolean;
+    mergeConsecutiveActions: boolean;
+    mergeTimeWindow: number;
+    enableSelectiveUndo: boolean;
+    enableBranches: boolean;
+}
+export declare const DEFAULT_UNDO_REDO_CONFIG: UndoRedoConfig;
+export declare class UndoRedoManager {
+    private config;
+    private executors;
+    private branches;
+    private activeBranchId;
+    private groups;
+    private snapshots;
+    private currentGroupId;
+    private actionsSinceSnapshot;
+    private isExecuting;
+    private lastActionTime;
+    private onHistoryChange?;
+    private onActionExecuted?;
+    private onSnapshotCreated?;
+    private getStateSnapshot?;
+    private restoreStateSnapshot?;
+    constructor(config?: Partial<UndoRedoConfig>);
+    registerExecutor(actionType: string, executor: ActionExecutor): void;
+    unregisterExecutor(actionType: string): void;
+    execute(action: Omit<UndoableAction, 'id' | 'timestamp'>): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    private undoSingleAction;
+    private redoSingleAction;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undoAction(actionId: string): boolean;
+    redoSelectiveAction(actionId: string): boolean;
+    beginGroup(name: string, description?: string): string;
+    endGroup(): void;
+    cancelGroup(): void;
+    private undoGroup;
+    private redoGroup;
+    createSnapshot(name: string, description?: string): HistorySnapshot | null;
+    private createAutoSnapshot;
+    restoreSnapshot(snapshotId: string): boolean;
+    getSnapshots(): HistorySnapshot[];
+    deleteSnapshot(snapshotId: string): boolean;
+    createBranch(name: string): HistoryBranch | null;
+    private createBranchFromCurrent;
+    switchBranch(branchId: string): boolean;
+    getBranches(): HistoryBranch[];
+    getActiveBranch(): HistoryBranch | null;
+    deleteBranch(branchId: string): boolean;
+    mergeBranch(branchId: string): boolean;
+    getHistory(): UndoableAction[];
+    getUndoHistory(): UndoableAction[];
+    getRedoHistory(): UndoableAction[];
+    getCurrentAction(): UndoableAction | null;
+    getActionsByCategory(category: ActionCategory): UndoableAction[];
+    getActionsByTarget(targetId: string): UndoableAction[];
+    getGroup(groupId: string): ActionGroup | undefined;
+    getHistoryTree(): HistoryTreeNode[];
+    private buildHistoryNodes;
+    setOnHistoryChange(callback: () => void): void;
+    setOnActionExecuted(callback: (action: UndoableAction, isUndo: boolean) => void): void;
+    setOnSnapshotCreated(callback: (snapshot: HistorySnapshot) => void): void;
+    setStateSnapshotFunctions(getSnapshot: () => string, restoreSnapshot: (data: string) => void): void;
+    private generateId;
+    private enforceHistoryLimit;
+    jumpToAction(actionId: string): boolean;
+    clear(): void;
+    serialize(): string;
+    deserialize(json: string): boolean;
+}
+export interface HistoryTreeNode {
+    id: string;
+    type: 'action' | 'group' | 'branch' | 'snapshot';
+    name: string;
+    children: HistoryTreeNode[];
+    isActive: boolean;
+    isCurrent: boolean;
+    isCollapsed?: boolean;
+    category?: ActionCategory;
+    timestamp?: number;
+    selectivelyUndone?: boolean;
+    parentId?: string;
+    forkIndex?: number;
+}
+export declare const CommonExecutors: {
+    setProperty: {
+        execute(data: {
+            target: Record<string, unknown>;
+            property: string;
+            value: unknown;
+        }): void;
+        undo(data: {
+            target: Record<string, unknown>;
+            property: string;
+            oldValue: unknown;
+        }): void;
+        merge(oldData: {
+            property: string;
+            value: unknown;
+        }, newData: {
+            property: string;
+            value: unknown;
+        }): {
+            value: unknown;
+            property: string;
+        } | null;
+    };
+    arrayPush: {
+        execute(data: {
+            array: unknown[];
+            value: unknown;
+        }): void;
+        undo(data: {
+            array: unknown[];
+        }): void;
+    };
+    arrayRemove: {
+        execute(data: {
+            array: unknown[];
+            index: number;
+        }): void;
+        undo(data: {
+            array: unknown[];
+            index: number;
+            value: unknown;
+        }): void;
+    };
+    mapSet: {
+        execute(data: {
+            map: Map<unknown, unknown>;
+            key: unknown;
+            value: unknown;
+        }): void;
+        undo(data: {
+            map: Map<unknown, unknown>;
+            key: unknown;
+            hadValue: boolean;
+            oldValue: unknown;
+        }): void;
+    };
+    mapDelete: {
+        execute(data: {
+            map: Map<unknown, unknown>;
+            key: unknown;
+        }): void;
+        undo(data: {
+            map: Map<unknown, unknown>;
+            key: unknown;
+            value: unknown;
+        }): void;
+    };
+};
+export declare function createUndoRedoManager(config?: Partial<UndoRedoConfig>): UndoRedoManager;
+export declare function createAction(name: string, actionType: string, category: ActionCategory, doData: unknown, undoData: unknown, options?: Partial<Omit<UndoableAction, 'id' | 'name' | 'actionType' | 'category' | 'timestamp' | 'doData' | 'undoData'>>): Omit<UndoableAction, 'id' | 'timestamp'>;

package/dist/types/editor/VRARMode.d.ts

@@ -0,0 +1,240 @@
+/**
+ * @file VRARMode.ts
+ * @description VR/AR Mode with WebXR integration and hand tracking
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - WebXR session management
+ * - VR headset support
+ * - AR passthrough mode
+ * - Hand tracking
+ * - Controller input
+ * - Spatial anchors
+ * - Room-scale setup
+ * - Teleportation movement
+ * - Haptic feedback
+ * - Mixed reality support
+ */
+export type XRSessionMode = 'inline' | 'immersive-vr' | 'immersive-ar';
+export type XRReferenceSpaceType = 'viewer' | 'local' | 'local-floor' | 'bounded-floor' | 'unbounded';
+export type HandSide = 'left' | 'right';
+export type ControllerHandedness = 'none' | 'left' | 'right';
+export type InputSourceTargetRayMode = 'gaze' | 'tracked-pointer' | 'screen' | 'transient-pointer';
+export type JointName = 'wrist' | 'thumb-metacarpal' | 'thumb-phalanx-proximal' | 'thumb-phalanx-distal' | 'thumb-tip' | 'index-finger-metacarpal' | 'index-finger-phalanx-proximal' | 'index-finger-phalanx-intermediate' | 'index-finger-phalanx-distal' | 'index-finger-tip' | 'middle-finger-metacarpal' | 'middle-finger-phalanx-proximal' | 'middle-finger-phalanx-intermediate' | 'middle-finger-phalanx-distal' | 'middle-finger-tip' | 'ring-finger-metacarpal' | 'ring-finger-phalanx-proximal' | 'ring-finger-phalanx-intermediate' | 'ring-finger-phalanx-distal' | 'ring-finger-tip' | 'pinky-finger-metacarpal' | 'pinky-finger-phalanx-proximal' | 'pinky-finger-phalanx-intermediate' | 'pinky-finger-phalanx-distal' | 'pinky-finger-tip';
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface Pose {
+    position: Vector3;
+    orientation: Quaternion;
+}
+export interface JointPose extends Pose {
+    radius: number;
+}
+export interface HandJoints {
+    wrist?: JointPose;
+    thumb: JointPose[];
+    index: JointPose[];
+    middle: JointPose[];
+    ring: JointPose[];
+    pinky: JointPose[];
+}
+export interface HandState {
+    side: HandSide;
+    joints: HandJoints;
+    isTracking: boolean;
+    pinchStrength: number;
+    gripStrength: number;
+}
+export interface ControllerState {
+    handedness: ControllerHandedness;
+    targetRayMode: InputSourceTargetRayMode;
+    pose?: Pose;
+    gripPose?: Pose;
+    buttons: ControllerButton[];
+    axes: number[];
+    isTracking: boolean;
+}
+export interface ControllerButton {
+    pressed: boolean;
+    touched: boolean;
+    value: number;
+}
+export interface HapticFeedback {
+    intensity: number;
+    duration: number;
+    startDelay?: number;
+}
+export interface SpatialAnchor {
+    id: string;
+    name: string;
+    pose: Pose;
+    createdAt: number;
+    persistent: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface RoomBoundary {
+    points: Vector3[];
+    height: number;
+}
+export interface XRSettings {
+    sessionMode: XRSessionMode;
+    referenceSpaceType: XRReferenceSpaceType;
+    requiredFeatures: string[];
+    optionalFeatures: string[];
+    framebufferScaleFactor: number;
+    depthSensing: boolean;
+    lightEstimation: boolean;
+    teleportEnabled: boolean;
+    continuousMovement: boolean;
+    snapTurnAngle: number;
+    vignetteOnMove: boolean;
+    handTrackingEnabled: boolean;
+    planeDetection: boolean;
+    hitTesting: boolean;
+    imageTracking: boolean;
+    roomScale: boolean;
+    boundaryVisible: boolean;
+}
+export type XRGesture = 'pinch' | 'grab' | 'point' | 'open_hand' | 'thumbs_up' | 'fist' | 'peace' | 'custom';
+export interface GestureDefinition {
+    id: string;
+    name: string;
+    type: XRGesture;
+    hand?: HandSide;
+    customChecker?: (hand: HandState) => boolean;
+}
+export interface TeleportTarget {
+    position: Vector3;
+    normal: Vector3;
+    valid: boolean;
+    surfaceType?: string;
+}
+export interface PlaneAnchor {
+    id: string;
+    pose: Pose;
+    polygon: Vector3[];
+    classification: 'floor' | 'wall' | 'ceiling' | 'table' | 'seat' | 'door' | 'window' | 'unknown';
+}
+export interface HitTestResult {
+    pose: Pose;
+    planeId?: string;
+}
+export interface ImageTarget {
+    id: string;
+    name: string;
+    widthInMeters: number;
+    imageData: ImageData | HTMLImageElement;
+    tracked: boolean;
+    pose?: Pose;
+}
+export declare const DEFAULT_XR_SETTINGS: XRSettings;
+export declare class VRARMode {
+    private xrSession;
+    private xrReferenceSpace;
+    private settings;
+    private isSupported;
+    private isSessionActive;
+    private frameId;
+    private controllers;
+    private hands;
+    private anchors;
+    private roomBoundary;
+    private detectedPlanes;
+    private teleportTarget;
+    private isTeleporting;
+    private imageTargets;
+    private registeredGestures;
+    private activeGestures;
+    private onSessionStarted?;
+    private onSessionEnded?;
+    private onFrame?;
+    private onControllerConnected?;
+    private onControllerDisconnected?;
+    private onHandTrackingUpdate?;
+    private onGestureDetected?;
+    private onGestureEnded?;
+    private onTeleport?;
+    private onPlaneDetected?;
+    private onImageTracked?;
+    private onAnchorAdded?;
+    private onAnchorRemoved?;
+    checkSupport(): Promise<{
+        vr: boolean;
+        ar: boolean;
+        handTracking: boolean;
+    }>;
+    isXRSupported(): boolean;
+    startSession(mode?: XRSessionMode): Promise<boolean>;
+    endSession(): Promise<void>;
+    private cleanup;
+    private setupSessionListeners;
+    private onXRFrame;
+    private updateInputSource;
+    private updateHandTracking;
+    private extractHandState;
+    private calculatePinchStrength;
+    private calculateGripStrength;
+    private distance;
+    private convertXRPose;
+    private onInputSourcesChange;
+    private onSelect;
+    private onSelectStart;
+    private onSelectEnd;
+    private onSqueeze;
+    private onSqueezeStart;
+    private onSqueezeEnd;
+    registerGesture(gesture: GestureDefinition): void;
+    unregisterGesture(gestureId: string): void;
+    private checkGestures;
+    private isGestureActive;
+    private updateTeleport;
+    setTeleportTarget(target: TeleportTarget): void;
+    private executeTeleport;
+    teleportTo(position: Vector3): void;
+    snapTurn(direction: 'left' | 'right'): void;
+    triggerHaptics(handedness: ControllerHandedness, feedback: HapticFeedback): void;
+    createAnchor(pose: Pose, name: string, persistent?: boolean, metadata?: Record<string, unknown>): Promise<SpatialAnchor | null>;
+    getAnchor(id: string): SpatialAnchor | undefined;
+    getAnchors(): SpatialAnchor[];
+    removeAnchor(id: string): boolean;
+    getDetectedPlanes(): PlaneAnchor[];
+    getPlanesByClassification(classification: PlaneAnchor['classification']): PlaneAnchor[];
+    addImageTarget(target: Omit<ImageTarget, 'tracked' | 'pose'>): void;
+    removeImageTarget(id: string): void;
+    getTrackedImages(): ImageTarget[];
+    getSession(): XRSession | null;
+    getReferenceSpace(): XRReferenceSpace | null;
+    isActive(): boolean;
+    getControllers(): ControllerState[];
+    getController(index: number): ControllerState | undefined;
+    getControllerByHandedness(handedness: ControllerHandedness): ControllerState | undefined;
+    getHand(side: HandSide): HandState | undefined;
+    getHands(): HandState[];
+    getRoomBoundary(): RoomBoundary | null;
+    getSettings(): XRSettings;
+    setSettings(settings: Partial<XRSettings>): void;
+    setOnSessionStarted(callback: () => void): void;
+    setOnSessionEnded(callback: () => void): void;
+    setOnFrame(callback: (time: number, frame: XRFrame) => void): void;
+    setOnControllerConnected(callback: (controller: ControllerState, index: number) => void): void;
+    setOnControllerDisconnected(callback: (index: number) => void): void;
+    setOnHandTrackingUpdate(callback: (hand: HandState) => void): void;
+    setOnGestureDetected(callback: (gesture: string, hand: HandSide) => void): void;
+    setOnGestureEnded(callback: (gesture: string, hand: HandSide) => void): void;
+    setOnTeleport(callback: (target: TeleportTarget) => void): void;
+    setOnPlaneDetected(callback: (plane: PlaneAnchor) => void): void;
+    setOnImageTracked(callback: (image: ImageTarget) => void): void;
+    setOnAnchorAdded(callback: (anchor: SpatialAnchor) => void): void;
+    setOnAnchorRemoved(callback: (anchorId: string) => void): void;
+}
+export declare function createVRARMode(): VRARMode;
+export declare function createDefaultGestures(): GestureDefinition[];

package/dist/types/editor/behavior-tree/BTDebugPanel.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @file Behavior Tree Editor - Debug Panel
+ * @description Debug panel for runtime inspection and debugging
+ * PRO-1.4: Professional Editor Features
+ */
+import type { BTStatus } from '../../ai/BehaviorTree';
+import type { BTDebugState, BTWatchExpression, BTExecutionStep, BTDebugStatistics } from './types';
+export declare class BTDebugPanel {
+    private state;
+    private listeners;
+    onStartDebug?: () => void;
+    onStopDebug?: () => void;
+    onStepDebug?: () => void;
+    onPauseDebug?: () => void;
+    onResumeDebug?: () => void;
+    onAddBreakpoint?: (nodeId: string) => void;
+    onRemoveBreakpoint?: (nodeId: string) => void;
+    constructor();
+    private createInitialState;
+    /** Start debugging */
+    start(): void;
+    /** Stop debugging */
+    stop(): void;
+    /** Step one tick */
+    step(): void;
+    /** Pause execution */
+    pause(): void;
+    /** Resume execution */
+    resume(): void;
+    /** Toggle pause state */
+    togglePause(): void;
+    /** Update debug state from runtime */
+    updateState(updates: Partial<BTDebugState>): void;
+    /** Set current node being executed */
+    setCurrentNode(nodeId: string | undefined): void;
+    /** Update blackboard snapshot */
+    updateBlackboard(snapshot: Record<string, unknown>): void;
+    /** Record execution step */
+    recordStep(step: BTExecutionStep): void;
+    /** Update statistics */
+    updateStatistics(updates: Partial<BTDebugStatistics>): void;
+    /** Add breakpoint */
+    addBreakpoint(nodeId: string): void;
+    /** Remove breakpoint */
+    removeBreakpoint(nodeId: string): void;
+    /** Toggle breakpoint */
+    toggleBreakpoint(nodeId: string): void;
+    /** Clear all breakpoints */
+    clearBreakpoints(): void;
+    /** Check if node has breakpoint */
+    hasBreakpoint(nodeId: string): boolean;
+    /** Add watch expression */
+    addWatch(expression: string): BTWatchExpression;
+    /** Remove watch expression */
+    removeWatch(watchId: string): void;
+    /** Update watch expression */
+    updateWatch(watchId: string, expression: string): void;
+    /** Clear all watches */
+    clearWatches(): void;
+    /** Evaluate a watch expression */
+    private evaluateWatch;
+    /** Re-evaluate all watches */
+    evaluateWatches(): void;
+    /** Get execution history */
+    getHistory(): BTExecutionStep[];
+    /** Clear execution history */
+    clearHistory(): void;
+    /** Get history for specific node */
+    getNodeHistory(nodeId: string): BTExecutionStep[];
+    /** Get last N steps */
+    getRecentHistory(count?: number): BTExecutionStep[];
+    /** Get statistics */
+    getStatistics(): BTDebugStatistics;
+    /** Get node execution count */
+    getNodeExecutionCount(nodeId: string): number;
+    /** Get node failure count */
+    getNodeFailureCount(nodeId: string): number;
+    /** Get node success rate */
+    getNodeSuccessRate(nodeId: string): number;
+    /** Get full state */
+    getState(): BTDebugState;
+    /** Check if debugging */
+    isDebugging(): boolean;
+    /** Check if paused */
+    isPaused(): boolean;
+    /** Get current node */
+    getCurrentNodeId(): string | undefined;
+    /** Subscribe to state changes */
+    subscribe(listener: () => void): () => void;
+    private notifyListeners;
+}
+export declare function createBTDebugPanel(): BTDebugPanel;
+/** Get status display info */
+export declare function getStatusInfo(status: BTStatus): {
+    label: string;
+    color: string;
+    icon: string;
+};
+/** Format execution time */
+export declare function formatExecutionTime(ms: number): string;
+/** Format blackboard value for display */
+export declare function formatBlackboardValue(value: unknown): string;

package/dist/types/editor/behavior-tree/BTEditorCanvas.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @file Behavior Tree Editor - Canvas
+ * @description Canvas component for visual editing of behavior trees
+ * PRO-1.4: Professional Editor Features
+ */
+import type { Vec2 } from '../../core/types';
+import type { BehaviorTreeEditor } from './BehaviorTreeEditor';
+import { BTEditorNodeRenderer, BTConnectionRenderer } from './BTEditorNode';
+import type { BTEditorConfig } from './types';
+export interface BTEditorCanvasState {
+    isDragging: boolean;
+    isPanning: boolean;
+    isBoxSelecting: boolean;
+    dragStartPosition: Vec2 | null;
+    dragStartNodePositions: Map<string, Vec2>;
+    boxSelectStart: Vec2 | null;
+    boxSelectEnd: Vec2 | null;
+    hoveredNodeId: string | null;
+    hoveredConnectionId: string | null;
+    contextMenuPosition: Vec2 | null;
+}
+export declare class BTEditorCanvas {
+    private canvas;
+    private ctx;
+    private editor;
+    private config;
+    private nodeRenderer;
+    private connectionRenderer;
+    private state;
+    private animationFrameId;
+    private resizeObserver;
+    onNodeClick?: (nodeId: string, event: MouseEvent) => void;
+    onNodeDoubleClick?: (nodeId: string, event: MouseEvent) => void;
+    onNodeContextMenu?: (nodeId: string, position: Vec2, event: MouseEvent) => void;
+    onConnectionContextMenu?: (connectionId: string, position: Vec2, event: MouseEvent) => void;
+    onCanvasContextMenu?: (position: Vec2, event: MouseEvent) => void;
+    onDrop?: (dataTransfer: DataTransfer, position: Vec2) => void;
+    constructor(canvas: HTMLCanvasElement, editor: BehaviorTreeEditor, config?: Partial<BTEditorConfig>);
+    /** Clean up resources */
+    dispose(): void;
+    private setupEventListeners;
+    private removeEventListeners;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleMouseLeave;
+    private handleWheel;
+    private handleDoubleClick;
+    private handleContextMenu;
+    private handleDragOver;
+    private handleDrop;
+    private handleKeyDown;
+    private startConnection;
+    private completeConnection;
+    private findNodeAtPosition;
+    private findConnectionAtPosition;
+    private updateHoverState;
+    private setupResizeObserver;
+    private resizeCanvas;
+    private startRenderLoop;
+    private render;
+    private renderGrid;
+    private renderBoxSelection;
+    private renderMinimap;
+    private getCanvasPosition;
+    private snapToGrid;
+    private normalizeRect;
+    /** Force redraw */
+    redraw(): void;
+    /** Get canvas element */
+    getCanvas(): HTMLCanvasElement;
+    /** Update configuration */
+    updateConfig(config: Partial<BTEditorConfig>): void;
+    /** Set custom node renderer */
+    setNodeRenderer(renderer: BTEditorNodeRenderer): void;
+    /** Set custom connection renderer */
+    setConnectionRenderer(renderer: BTConnectionRenderer): void;
+}
+export declare function createBTEditorCanvas(canvas: HTMLCanvasElement, editor: BehaviorTreeEditor, config?: Partial<BTEditorConfig>): BTEditorCanvas;