@nice2dev/game-engine 1.1.5 → 1.1.6

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

@@ -0,0 +1,57 @@
+/**
+ * @file Behavior Tree Editor - Editor Node
+ * @description Visual representation of a behavior tree node in the editor
+ * PRO-1.4: Professional Editor Features
+ */
+import type { Vec2 } from '../../core/types';
+import type { BTEditorNodeData, BTEditorConfig } from './types';
+import { BT_NODE_COLORS, BT_STATUS_COLORS } from './types';
+export interface BTEditorNodeRenderer {
+    /** Render the node to a canvas context */
+    render(ctx: CanvasRenderingContext2D, node: BTEditorNodeData, config: BTEditorConfig): void;
+    /** Check if point is inside node */
+    hitTest(point: Vec2, node: BTEditorNodeData): boolean;
+    /** Check if point is on input connector */
+    hitTestInput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
+    /** Check if point is on output connector */
+    hitTestOutput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
+    /** Get input connector position */
+    getInputPosition(node: BTEditorNodeData, config: BTEditorConfig): Vec2;
+    /** Get output connector position */
+    getOutputPosition(node: BTEditorNodeData, config: BTEditorConfig): Vec2;
+}
+export declare class DefaultBTNodeRenderer implements BTEditorNodeRenderer {
+    private connectorRadius;
+    private connectorHitRadius;
+    render(ctx: CanvasRenderingContext2D, node: BTEditorNodeData, config: BTEditorConfig): void;
+    hitTest(point: Vec2, node: BTEditorNodeData): boolean;
+    hitTestInput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
+    hitTestOutput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
+    getInputPosition(node: BTEditorNodeData, config: BTEditorConfig): Vec2;
+    getOutputPosition(node: BTEditorNodeData, _config: BTEditorConfig): Vec2;
+    private drawConnector;
+    private drawBadge;
+    private roundRect;
+    private truncateText;
+    private getCategoryIcon;
+}
+export interface BTConnectionRenderer {
+    /** Render connection */
+    render(ctx: CanvasRenderingContext2D, startPos: Vec2, endPos: Vec2, selected: boolean, active: boolean, config: BTEditorConfig): void;
+    /** Hit test connection */
+    hitTest(point: Vec2, startPos: Vec2, endPos: Vec2, config: BTEditorConfig): boolean;
+}
+export declare class DefaultBTConnectionRenderer implements BTConnectionRenderer {
+    render(ctx: CanvasRenderingContext2D, startPos: Vec2, endPos: Vec2, selected: boolean, active: boolean, config: BTEditorConfig): void;
+    hitTest(point: Vec2, startPos: Vec2, endPos: Vec2, config: BTEditorConfig): boolean;
+    private getBezierPoint;
+}
+export interface BTNodeTheme {
+    name: string;
+    colors: typeof BT_NODE_COLORS;
+    statusColors: typeof BT_STATUS_COLORS;
+}
+export declare const defaultTheme: BTNodeTheme;
+export declare const lightTheme: BTNodeTheme;
+export declare function createNodeRenderer(): BTEditorNodeRenderer;
+export declare function createConnectionRenderer(): BTConnectionRenderer;

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

@@ -0,0 +1,74 @@
+/**
+ * @file Behavior Tree Editor - Toolbar
+ * @description Toolbar component for editor actions
+ * PRO-1.4: Professional Editor Features
+ */
+import type { BehaviorTreeEditor } from './BehaviorTreeEditor';
+import type { BTEditorMode } from './types';
+export interface BTToolbarAction {
+    id: string;
+    label: string;
+    icon: string;
+    shortcut?: string;
+    tooltip?: string;
+    disabled?: boolean;
+    active?: boolean;
+    group?: string;
+    execute: () => void;
+}
+export interface BTToolbarGroup {
+    id: string;
+    label?: string;
+    actions: BTToolbarAction[];
+}
+export declare class BTEditorToolbar {
+    private editor;
+    private customActions;
+    private listeners;
+    constructor(editor: BehaviorTreeEditor);
+    /** Get all toolbar groups */
+    getGroups(): BTToolbarGroup[];
+    private getFileGroup;
+    private getEditGroup;
+    private getViewGroup;
+    private getLayoutGroup;
+    private getDebugGroup;
+    private getCustomGroups;
+    private handleDelete;
+    onSave?: () => void;
+    onExport?: () => void;
+    onImport?: () => void;
+    onValidate?: (result: {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    }) => void;
+    private triggerSave;
+    private triggerExport;
+    private triggerImport;
+    private triggerValidation;
+    /** Add custom toolbar action */
+    addAction(action: BTToolbarAction): void;
+    /** Remove custom toolbar action */
+    removeAction(actionId: string): void;
+    /** Get action by ID */
+    getAction(actionId: string): BTToolbarAction | undefined;
+    /** Execute action by ID */
+    executeAction(actionId: string): void;
+    /** Get all keyboard shortcuts */
+    getShortcuts(): Map<string, BTToolbarAction>;
+    /** Handle keyboard shortcut */
+    handleShortcut(event: KeyboardEvent): boolean;
+    private formatShortcut;
+    /** Update toolbar state */
+    update(): void;
+    /** Get current mode */
+    getMode(): BTEditorMode;
+    /** Check if modified */
+    isModified(): boolean;
+    /** Subscribe to state changes */
+    subscribe(listener: () => void): () => void;
+    private notifyListeners;
+}
+export declare function createBTEditorToolbar(editor: BehaviorTreeEditor): BTEditorToolbar;
+export declare const TOOLBAR_ICONS: Record<string, string>;

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

@@ -0,0 +1,72 @@
+/**
+ * @file Behavior Tree Editor - Node Palette
+ * @description Node palette for selecting and adding nodes to the behavior tree
+ * PRO-1.4: Professional Editor Features
+ */
+import type { BTNodeDefinition, BTNodeType } from '../../ai/BehaviorTree';
+import type { BTPaletteCategory, BTPaletteNode } from './types';
+export interface BTNodePaletteState {
+    searchQuery: string;
+    expandedCategories: Set<BTNodeType>;
+    favorites: Set<string>;
+    recentlyUsed: string[];
+    maxRecentlyUsed: number;
+}
+export declare class BTNodePalette {
+    private definitions;
+    private state;
+    private listeners;
+    onNodeDragStart?: (definition: BTNodeDefinition, event: DragEvent) => void;
+    onNodeAdd?: (definition: BTNodeDefinition) => void;
+    constructor();
+    /** Set available node definitions */
+    setDefinitions(definitions: BTNodeDefinition[]): void;
+    /** Get all definitions */
+    getDefinitions(): BTNodeDefinition[];
+    /** Get definition by type */
+    getDefinition(type: string): BTNodeDefinition | undefined;
+    /** Get categories with filtered nodes */
+    getCategories(): BTPaletteCategory[];
+    private createCategory;
+    private toPaletteNode;
+    private generateSearchTerms;
+    /** Update search query */
+    setSearchQuery(query: string): void;
+    /** Get current search query */
+    getSearchQuery(): string;
+    /** Check if definition matches search */
+    private matchesSearch;
+    /** Get filtered nodes across all categories */
+    getFilteredNodes(): BTPaletteNode[];
+    /** Toggle category expansion */
+    toggleCategory(category: BTNodeType): void;
+    /** Expand all categories */
+    expandAll(): void;
+    /** Collapse all categories */
+    collapseAll(): void;
+    /** Toggle favorite status */
+    toggleFavorite(type: string): void;
+    /** Check if node is favorite */
+    isFavorite(type: string): boolean;
+    /** Get favorite nodes */
+    getFavorites(): BTPaletteNode[];
+    private loadFavorites;
+    private saveFavorites;
+    /** Add to recently used */
+    addRecentlyUsed(type: string): void;
+    /** Get recently used nodes */
+    getRecentlyUsed(): BTPaletteNode[];
+    /** Clear recently used */
+    clearRecentlyUsed(): void;
+    private loadRecentlyUsed;
+    private saveRecentlyUsed;
+    /** Handle node drag start */
+    handleDragStart(type: string, event: DragEvent): void;
+    /** Handle node click (add node) */
+    handleNodeClick(type: string): void;
+    /** Subscribe to state changes */
+    subscribe(listener: () => void): () => void;
+    private notifyListeners;
+}
+export declare function createBTNodePalette(): BTNodePalette;
+export declare function getBuiltInNodeDefinitions(): Partial<BTNodeDefinition>[];

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

@@ -0,0 +1,66 @@
+/**
+ * @file Behavior Tree Editor - Property Panel
+ * @description Property panel for editing selected node properties
+ * PRO-1.4: Professional Editor Features
+ */
+import type { BTNodeDefinition, BTPropertyDef } from '../../ai/BehaviorTree';
+import type { BTEditorNodeData, BTBlackboardKeyDef } from './types';
+export interface BTPropertyValue {
+    name: string;
+    value: unknown;
+    definition?: BTPropertyDef;
+    error?: string;
+    modified: boolean;
+}
+export interface BTPropertyPanelState {
+    selectedNode: BTEditorNodeData | null;
+    nodeDefinition: BTNodeDefinition | null;
+    properties: BTPropertyValue[];
+    blackboardKeys: BTBlackboardKeyDef[];
+    collapsed: boolean;
+}
+export declare class BTPropertyPanel {
+    private state;
+    private listeners;
+    onPropertyChange?: (nodeId: string, property: string, value: unknown) => void;
+    onNameChange?: (nodeId: string, name: string) => void;
+    onCommentChange?: (nodeId: string, comment: string) => void;
+    constructor();
+    /** Set the selected node */
+    setSelectedNode(node: BTEditorNodeData | null, definition: BTNodeDefinition | null): void;
+    /** Get selected node */
+    getSelectedNode(): BTEditorNodeData | null;
+    /** Set blackboard keys for key selection */
+    setBlackboardKeys(keys: BTBlackboardKeyDef[]): void;
+    private buildProperties;
+    /** Update property value */
+    setProperty(name: string, value: unknown): void;
+    /** Reset property to default */
+    resetProperty(name: string): void;
+    /** Set node name */
+    setName(name: string): void;
+    /** Set node comment */
+    setComment(comment: string): void;
+    private validateProperty;
+    /** Validate all properties */
+    validateAll(): boolean;
+    /** Get current state */
+    getState(): BTPropertyPanelState;
+    /** Toggle collapsed state */
+    toggleCollapsed(): void;
+    /** Subscribe to state changes */
+    subscribe(listener: () => void): () => void;
+    private notifyListeners;
+}
+export interface BTPropertyEditorProps<T = unknown> {
+    value: T;
+    definition: BTPropertyDef;
+    onChange: (value: T) => void;
+    error?: string;
+    disabled?: boolean;
+}
+/** Get editor type for property */
+export declare function getPropertyEditorType(definition: BTPropertyDef): string;
+export declare function createBTPropertyPanel(): BTPropertyPanel;
+export declare function formatPropertyValue(value: unknown, definition?: BTPropertyDef): string;
+export declare function parsePropertyValue(input: string, definition: BTPropertyDef): unknown;

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;