@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,186 @@
+/**
+ * @file Behavior Tree Editor - Main Editor
+ * @description Main editor class for graphical Behavior Tree editing
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Visual node-based editing
+ * - Real-time preview and debugging
+ * - Undo/Redo support
+ * - Copy/Paste/Duplicate
+ * - Auto-layout
+ * - Validation
+ * - Export/Import
+ */
+import type { BTNodeType, BTNodeDefinition as _BTNodeDefinition, BehaviorTree } from '../../ai/BehaviorTree';
+import { BTNodeRegistry } from '../../ai/BehaviorTree';
+import type { Vec2 } from '../../core/types';
+import type { BTEditorConfig, BTEditorMode, BTSelection, BTClipboard, BTViewport as _BTViewport, BTEditorHistory, BTEditorNodeData, BTConnectionData, BTPendingConnection as _BTPendingConnection, BTDebugState, BTValidationResult, BTEditorEventType, BTEditorEventHandler, BTSearchOptions, BTFilterOptions } from './types';
+export declare class BehaviorTreeEditor {
+    config: BTEditorConfig;
+    mode: BTEditorMode;
+    nodes: Map<string, BTEditorNodeData>;
+    connections: Map<string, BTConnectionData>;
+    selection: BTSelection;
+    viewport: _BTViewport;
+    clipboard: BTClipboard | null;
+    pendingConnection: _BTPendingConnection | null;
+    history: BTEditorHistory;
+    tree: BehaviorTree | null;
+    registry: BTNodeRegistry;
+    debugState: BTDebugState;
+    name: string;
+    description: string;
+    author: string;
+    rootNodeId: string | null;
+    modified: boolean;
+    private eventListeners;
+    constructor(config?: Partial<BTEditorConfig>);
+    private createInitialDebugState;
+    /** Initialize with a new empty tree */
+    createNew(name?: string): void;
+    /** Clear all state */
+    clear(): void;
+    /** Add a new node */
+    addNode(type: string, position: Vec2, properties?: Record<string, unknown>): BTEditorNodeData;
+    /** Delete node(s) */
+    deleteNodes(nodeIds: string[]): void;
+    /** Duplicate node(s) */
+    duplicateNodes(nodeIds: string[]): BTEditorNodeData[];
+    /** Move node(s) */
+    moveNodes(nodeIds: string[], delta: Vec2): void;
+    /** Update node property */
+    setNodeProperty(nodeId: string, property: string, value: unknown): void;
+    /** Rename node */
+    renameNode(nodeId: string, name: string): void;
+    /** Set node comment */
+    setNodeComment(nodeId: string, comment: string): void;
+    /** Toggle node collapse */
+    toggleNodeCollapse(nodeId: string): void;
+    /** Add a connection between nodes */
+    addConnection(sourceNodeId: string, targetNodeId: string): BTConnectionData | null;
+    /** Delete connection(s) */
+    deleteConnections(connectionIds: string[]): void;
+    /** Check if connection is valid */
+    canConnect(sourceNodeId: string, targetNodeId: string): boolean;
+    /** Check if adding connection would create a cycle */
+    private wouldCreateCycle;
+    /** Reorder children of a node */
+    reorderChildren(parentNodeId: string, childOrder: string[]): void;
+    /** Get connections from parent to children */
+    getChildConnections(nodeId: string): BTConnectionData[];
+    /** Get parent connection */
+    getParentConnection(nodeId: string): BTConnectionData | null;
+    /** Select node(s) */
+    selectNodes(nodeIds: string[], addToSelection?: boolean): void;
+    /** Select connection(s) */
+    selectConnections(connectionIds: string[], addToSelection?: boolean): void;
+    /** Clear selection */
+    clearSelection(): void;
+    /** Select all nodes */
+    selectAll(): void;
+    /** Box select nodes in rect */
+    boxSelect(rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, addToSelection?: boolean): void;
+    private rectContainsNode;
+    /** Copy selected nodes */
+    copy(): void;
+    /** Cut selected nodes */
+    cut(): void;
+    /** Paste from clipboard */
+    paste(position?: Vec2): BTEditorNodeData[];
+    /** Record an action for undo */
+    private recordAction;
+    /** Undo last action */
+    undo(): void;
+    /** Redo last undone action */
+    redo(): void;
+    private applyUndo;
+    private applyRedo;
+    /** Check if can undo */
+    canUndo(): boolean;
+    /** Check if can redo */
+    canRedo(): boolean;
+    /** Pan viewport */
+    pan(delta: Vec2): void;
+    /** Set pan position */
+    setPan(pan: Vec2): void;
+    /** Zoom viewport */
+    zoom(delta: number, center?: Vec2): void;
+    /** Set zoom level */
+    setZoom(zoom: number): void;
+    /** Reset viewport */
+    resetViewport(): void;
+    /** Fit content in viewport */
+    fitContent(): void;
+    /** Center on node */
+    centerOnNode(nodeId: string): void;
+    /** Validate the tree */
+    validate(): BTValidationResult;
+    /** Get all nodes connected to root */
+    private getConnectedNodes;
+    /** Search nodes */
+    searchNodes(options: BTSearchOptions): BTEditorNodeData[];
+    /** Filter nodes */
+    filterNodes(options: BTFilterOptions): BTEditorNodeData[];
+    /** Auto-layout the tree */
+    autoLayout(): void;
+    /** Calculate layout positions */
+    private calculateLayout;
+    private buildLayoutTree;
+    private layoutSubtree;
+    private extractPositions;
+    /** Start debugging */
+    startDebug(): void;
+    /** Stop debugging */
+    stopDebug(): void;
+    /** Step execution */
+    stepDebug(): void;
+    /** Pause debugging */
+    pauseDebug(): void;
+    /** Resume debugging */
+    resumeDebug(): void;
+    /** Add breakpoint */
+    addBreakpoint(nodeId: string): void;
+    /** Remove breakpoint */
+    removeBreakpoint(nodeId: string): void;
+    /** Toggle breakpoint */
+    toggleBreakpoint(nodeId: string): void;
+    private createDebugContext;
+    private updateNodeStatuses;
+    /** Build runtime BehaviorTree from editor data */
+    private buildRuntimeTree;
+    /** Generate unique ID */
+    private generateId;
+    /** Snap position to grid */
+    private snapToGrid;
+    /** Get content bounds */
+    getContentBounds(): {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    /** Convert canvas position to screen position */
+    canvasToScreen(position: Vec2): Vec2;
+    /** Convert screen position to canvas position */
+    screenToCanvas(position: Vec2): Vec2;
+    /** Add event listener */
+    on<T>(type: BTEditorEventType, handler: BTEditorEventHandler<T>): () => void;
+    /** Remove event listener */
+    off<T>(type: BTEditorEventType, handler: BTEditorEventHandler<T>): void;
+    /** Emit event */
+    private emitEvent;
+    /** Get node definitions */
+    getNodeDefinitions(): _BTNodeDefinition[];
+    /** Get definitions by category */
+    getNodeDefinitionsByCategory(category: BTNodeType): _BTNodeDefinition[];
+    /** Register custom node */
+    registerNode(definition: _BTNodeDefinition): void;
+}
+/** Create a new Behavior Tree Editor */
+export declare function createBehaviorTreeEditor(config?: Partial<BTEditorConfig>): BehaviorTreeEditor;

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

@@ -0,0 +1,14 @@
+/**
+ * @file Behavior Tree Editor - Index
+ * @description Exports for the graphical Behavior Tree Editor
+ * PRO-1.4: Professional Editor Features
+ */
+export * from './types';
+export * from './BehaviorTreeEditor';
+export * from './BTEditorNode';
+export * from './BTEditorCanvas';
+export * from './BTNodePalette';
+export * from './BTPropertyPanel';
+export * from './BTDebugPanel';
+export * from './BTEditorToolbar';
+export * from './serialization';

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

@@ -0,0 +1,30 @@
+/**
+ * @file Behavior Tree Editor - Serialization
+ * @description Import/Export utilities for behavior trees
+ * PRO-1.4: Professional Editor Features
+ */
+import type { BehaviorTree } from '../../ai/BehaviorTree';
+import type { BehaviorTreeEditor } from './BehaviorTreeEditor';
+import type { BTTreeData } from './types';
+/** Serialize editor state to JSON */
+export declare function serializeBehaviorTree(editor: BehaviorTreeEditor): BTTreeData;
+/** Deserialize JSON to editor */
+export declare function deserializeBehaviorTree(editor: BehaviorTreeEditor, data: BTTreeData): void;
+export interface BTExportOptions {
+    format: 'json' | 'yaml' | 'xml' | 'typescript';
+    pretty: boolean;
+    includeComments: boolean;
+    includeMetadata: boolean;
+}
+/** Export behavior tree to string */
+export declare function exportBehaviorTree(editor: BehaviorTreeEditor, options?: Partial<BTExportOptions>): string;
+/** Import behavior tree from string */
+export declare function importBehaviorTree(editor: BehaviorTreeEditor, content: string, format?: string): void;
+/** Download behavior tree as file */
+export declare function downloadBehaviorTree(editor: BehaviorTreeEditor, options?: Partial<BTExportOptions>): void;
+/** Open file picker and import */
+export declare function openBehaviorTreeFile(editor: BehaviorTreeEditor): Promise<void>;
+/** Convert editor tree to runtime BehaviorTree */
+export declare function toRuntimeTree(editor: BehaviorTreeEditor): BehaviorTree | null;
+/** Convert runtime BehaviorTree to editor format */
+export declare function fromRuntimeTree(editor: BehaviorTreeEditor, tree: BehaviorTree): void;

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

@@ -0,0 +1,299 @@
+/**
+ * @file Behavior Tree Editor - Types
+ * @description Type definitions for the graphical Behavior Tree Editor
+ * PRO-1.4: Professional Editor Features
+ */
+import type { BTNodeType, BTNodeDefinition as _BTNodeDefinition, BTStatus as _BTStatus, BTVisualStatus } from '../../ai/BehaviorTree';
+import type { Vec2 } from '../../core/types';
+/** Editor mode */
+export type BTEditorMode = 'edit' | 'debug' | 'preview' | 'readonly';
+/** Selection state */
+export interface BTSelection {
+    type: 'node' | 'connection' | 'none';
+    ids: string[];
+}
+/** Clipboard for copy/paste */
+export interface BTClipboard {
+    nodes: BTEditorNodeData[];
+    connections: BTConnectionData[];
+    offset: Vec2;
+}
+/** Editor viewport state */
+export interface BTViewport {
+    pan: Vec2;
+    zoom: number;
+    minZoom: number;
+    maxZoom: number;
+}
+/** Undo/Redo action */
+export interface BTEditorAction {
+    type: string;
+    description: string;
+    data: unknown;
+    timestamp: number;
+}
+/** Editor history for undo/redo */
+export interface BTEditorHistory {
+    undoStack: BTEditorAction[];
+    redoStack: BTEditorAction[];
+    maxSize: number;
+}
+/** Node visual state in editor */
+export interface BTEditorNodeData {
+    id: string;
+    type: string;
+    category: BTNodeType;
+    name: string;
+    /** Position in canvas space */
+    position: Vec2;
+    /** Size for layout */
+    size: {
+        width: number;
+        height: number;
+    };
+    /** Custom properties */
+    properties: Record<string, unknown>;
+    /** Comment/documentation */
+    comment?: string;
+    /** Is collapsed (hide children) */
+    collapsed: boolean;
+    /** Is selected */
+    selected: boolean;
+    /** Is dragging */
+    dragging: boolean;
+    /** Runtime status (from debugger) */
+    runtimeStatus: BTVisualStatus;
+    /** Last execution time in ms */
+    executionTime?: number;
+    /** Validation errors */
+    errors: string[];
+    /** Validation warnings */
+    warnings: string[];
+}
+/** Connection between nodes */
+export interface BTConnectionData {
+    id: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    /** Connection path points for rendering */
+    points?: Vec2[];
+    /** Is selected */
+    selected: boolean;
+    /** Runtime status */
+    active: boolean;
+    /** Child index (for ordering in composites) */
+    childIndex: number;
+}
+/** Pending connection while dragging */
+export interface BTPendingConnection {
+    sourceNodeId: string;
+    startPosition: Vec2;
+    currentPosition: Vec2;
+    type: 'output' | 'input';
+}
+/** Editor configuration */
+export interface BTEditorConfig {
+    /** Canvas settings */
+    canvas: {
+        backgroundColor: string;
+        gridSize: number;
+        gridColor: string;
+        gridSubdivisions: number;
+        snapToGrid: boolean;
+        showGrid: boolean;
+        showMinimap: boolean;
+        minimapScale: number;
+    };
+    /** Node settings */
+    nodes: {
+        defaultWidth: number;
+        defaultHeight: number;
+        headerHeight: number;
+        borderRadius: number;
+        fontSize: number;
+        padding: number;
+        spacing: number;
+        showIcons: boolean;
+        showStatus: boolean;
+        showExecutionTime: boolean;
+    };
+    /** Connection settings */
+    connections: {
+        lineWidth: number;
+        curveOffset: number;
+        arrowSize: number;
+        hitTolerance: number;
+        animateActive: boolean;
+    };
+    /** Debug settings */
+    debug: {
+        highlightActive: boolean;
+        showBlackboard: boolean;
+        showStatistics: boolean;
+        stepDelay: number;
+    };
+    /** Interaction settings */
+    interaction: {
+        multiSelect: boolean;
+        boxSelect: boolean;
+        dragThreshold: number;
+        doubleClickTime: number;
+        zoomSensitivity: number;
+    };
+    /** Auto-layout settings */
+    layout: {
+        enabled: boolean;
+        direction: 'horizontal' | 'vertical';
+        nodeSpacingX: number;
+        nodeSpacingY: number;
+        levelSpacing: number;
+    };
+}
+/** Default editor configuration */
+export declare const DEFAULT_BT_EDITOR_CONFIG: BTEditorConfig;
+export declare const BT_NODE_COLORS: Record<BTNodeType, {
+    background: string;
+    border: string;
+    text: string;
+}>;
+/** Status colors */
+export declare const BT_STATUS_COLORS: Record<BTVisualStatus, string>;
+export type BTEditorEventType = 'node:select' | 'node:deselect' | 'node:move' | 'node:add' | 'node:delete' | 'node:duplicate' | 'node:property-change' | 'connection:add' | 'connection:delete' | 'selection:change' | 'viewport:pan' | 'viewport:zoom' | 'history:undo' | 'history:redo' | 'tree:save' | 'tree:load' | 'debug:start' | 'debug:stop' | 'debug:step' | 'debug:breakpoint-hit';
+export interface BTEditorEvent<T = unknown> {
+    type: BTEditorEventType;
+    data: T;
+    timestamp: number;
+}
+export type BTEditorEventHandler<T = unknown> = (event: BTEditorEvent<T>) => void;
+export interface BTPaletteCategory {
+    id: BTNodeType;
+    name: string;
+    icon: string;
+    color: string;
+    expanded: boolean;
+    nodes: BTPaletteNode[];
+}
+export interface BTPaletteNode {
+    type: string;
+    definition: _BTNodeDefinition;
+    searchTerms: string[];
+    favorite: boolean;
+    recentlyUsed: boolean;
+}
+export interface BTValidationResult {
+    valid: boolean;
+    errors: BTValidationMessage[];
+    warnings: BTValidationMessage[];
+}
+export interface BTValidationMessage {
+    nodeId?: string;
+    connectionId?: string;
+    severity: 'error' | 'warning' | 'info';
+    code: string;
+    message: string;
+}
+/** Validation rule */
+export interface BTValidationRule {
+    id: string;
+    name: string;
+    description: string;
+    severity: 'error' | 'warning' | 'info';
+    validate: (nodes: BTEditorNodeData[], connections: BTConnectionData[]) => BTValidationMessage[];
+}
+export interface BTTreeData {
+    version: string;
+    name: string;
+    description?: string;
+    author?: string;
+    created: string;
+    modified: string;
+    nodes: BTEditorNodeData[];
+    connections: BTConnectionData[];
+    rootNodeId?: string;
+    blackboardKeys: BTBlackboardKeyDef[];
+    variables: BTVariableDef[];
+    metadata?: Record<string, unknown>;
+}
+export interface BTBlackboardKeyDef {
+    name: string;
+    type: string;
+    defaultValue?: unknown;
+    description?: string;
+}
+export interface BTVariableDef {
+    name: string;
+    type: string;
+    value: unknown;
+    scope: 'local' | 'tree' | 'global';
+}
+export interface BTDebugState {
+    isDebugging: boolean;
+    isPaused: boolean;
+    currentNodeId?: string;
+    breakpoints: Set<string>;
+    watchExpressions: BTWatchExpression[];
+    blackboardSnapshot: Record<string, unknown>;
+    executionHistory: BTExecutionStep[];
+    statistics: BTDebugStatistics;
+}
+export interface BTWatchExpression {
+    id: string;
+    expression: string;
+    value: unknown;
+    error?: string;
+}
+export interface BTExecutionStep {
+    nodeId: string;
+    nodeName: string;
+    status: _BTStatus;
+    timestamp: number;
+    duration: number;
+    blackboardChanges?: Record<string, {
+        old: unknown;
+        new: unknown;
+    }>;
+}
+export interface BTDebugStatistics {
+    totalTicks: number;
+    averageTickTime: number;
+    nodeExecutionCounts: Map<string, number>;
+    nodeFailureCounts: Map<string, number>;
+    uptime: number;
+}
+export interface BTLayoutNode {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    children: BTLayoutNode[];
+    parent?: BTLayoutNode;
+    depth: number;
+    offset: number;
+    thread?: BTLayoutNode;
+}
+export interface BTLayoutResult {
+    nodes: Map<string, Vec2>;
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+}
+export interface BTSearchOptions {
+    query: string;
+    searchInNames: boolean;
+    searchInTypes: boolean;
+    searchInComments: boolean;
+    searchInProperties: boolean;
+    caseSensitive: boolean;
+    useRegex: boolean;
+}
+export interface BTFilterOptions {
+    categories: BTNodeType[];
+    statuses: BTVisualStatus[];
+    hasErrors: boolean | null;
+    hasWarnings: boolean | null;
+    hasBreakpoint: boolean | null;
+}

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

@@ -1,8 +1,20 @@
-export { NiceGameEditor, UndoStack, useEditor, serializeProject, deserializeProject } from './NiceGameEditor';
+export { NiceGameEditor, UndoStack, useEditor, serializeProject, deserializeProject, } from './NiceGameEditor';
 export type { NiceGameEditorProps, EditorContextValue, EditorState, EditorTool, EditorMode, EditorPanel, UndoEntry, } from './NiceGameEditor';
 export { createGizmoState, getSelectionRect, entitiesInRect, snapToGrid, snapVec2ToGrid, renderGrid, renderTranslateGizmo, renderRotateGizmo, renderScaleGizmo, hitTestGizmoAxis, pickEntityAt, copyEntities, pasteEntities, } from './SceneEditor';
-export type { GizmoMode, GizmoAxis, GizmoState, SelectionBox, ClipboardEntry, } from './SceneEditor';
+export type { GizmoMode, GizmoAxis, GizmoState, SelectionBox, ClipboardEntry } from './SceneEditor';
 export { AssetManager } from './AssetManager';
 export type { AssetMetadata, AssetFolder } from './AssetManager';
 export { Profiler, FPSCounter, ConsoleLogger, snapshotEntity, snapshotWorld, renderCollisionDebug, getMemoryStats, } from './DebugTools';
 export type { ProfilerSample, ProfilerFrame, LogLevel, LogEntry, EntitySnapshot, MemoryStats, } from './DebugTools';
+export * from './behavior-tree';
+export * from './state-machine';
+export { NiceNodeGraph } from './NiceNodeGraph';
+export type { NiceNodeGraphProps, NiceNodeGraphRef } from './NiceNodeGraph';
+export { NiceAnimationTimeline } from './NiceAnimationTimeline';
+export type { NiceAnimationTimelineProps, NiceAnimationTimelineRef, AnimationTimelineTheme, KeyframeValue, Keyframe, EasingType, AnimationTrack, AnimationLayer, AnimationClipData, AnimationEvent, } from './NiceAnimationTimeline';
+export { NiceMaterialEditor } from './NiceMaterialEditor';
+export type { NiceMaterialEditorProps, NiceMaterialEditorRef, MaterialEditorTheme, ShaderNodeType, ShaderPin, ShaderNode, ShaderConnection, MaterialData, MaterialParameter, MaterialTexture, RenderState, } from './NiceMaterialEditor';
+export { NiceParticleEditor } from './NiceParticleEditor';
+export type { NiceParticleEditorProps, NiceParticleEditorRef, ParticleEditorTheme, ParticleCurve, ParticleGradient, EmitterShape, ParticleModule, ParticleModuleType, ParticleSystemData, } from './NiceParticleEditor';
+export { NiceLevelEditor } from './NiceLevelEditor';
+export type { NiceLevelEditorProps, NiceLevelEditorRef, LevelEditorTheme, LevelLayer, LevelObject, TerrainData, TerrainLayer, TreeInstance, DetailInstance, SplineData, SplinePoint, StreamingZone, LevelData, LightmapSettings, NavmeshSettings, EnvironmentSettings, LevelTool, } from './NiceLevelEditor';

package/dist/types/editor/state-machine/SMEditorCanvas.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @file state-machine/SMEditorCanvas.ts
+ * @description Canvas rendering and interaction for State Machine Editor
+ * PRO-1.4: Professional Editor Features
+ */
+import type { Vec2 } from '../../core/types';
+import type { StateMachineEditor } from './StateMachineEditor';
+import { SMBoxSelection } from './types';
+export interface SMEditorCanvasState {
+    isDragging: boolean;
+    isPanning: boolean;
+    isBoxSelecting: boolean;
+    boxSelection: SMBoxSelection;
+    lastMousePos: Vec2;
+    dragStartPos: Vec2;
+    hoveredStateId: string | null;
+    hoveredTransitionId: string | null;
+}
+export declare class SMEditorCanvas {
+    private editor;
+    private canvas;
+    private ctx;
+    private state;
+    private animationFrameId;
+    private resizeObserver;
+    constructor(editor: StateMachineEditor);
+    attach(canvas: HTMLCanvasElement): void;
+    detach(): void;
+    private handleResize;
+    private startRenderLoop;
+    private stopRenderLoop;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleMouseLeave;
+    private handleWheel;
+    private handleDoubleClick;
+    private handleContextMenu;
+    private handleKeyDown;
+    private handleKeyUp;
+    private hitTest;
+    private isPointInState;
+    private isPointNearTransition;
+    private distanceToLineSegment;
+    private render;
+    private drawGrid;
+    private drawState;
+    private drawStateTypeIndicator;
+    private drawTransition;
+    private drawSelfLoop;
+    private drawPendingConnection;
+    private drawArrow;
+    private drawBoxSelection;
+    private drawMinimap;
+    private getMousePosition;
+    private getStateCenter;
+    private getStateEdgePoint;
+    private getBoxSelectionRect;
+    private roundRect;
+}
+export declare function createSMEditorCanvas(editor: StateMachineEditor): SMEditorCanvas;