@nice2dev/game-engine 1.1.5 → 1.1.6

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;

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

@@ -0,0 +1,139 @@
+/**
+ * @file state-machine/StateMachineEditor.ts
+ * @description Main State Machine Editor class
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Visual state machine editing
+ * - Multi-layer support
+ * - State/transition management
+ * - Parameter management
+ * - Undo/Redo history
+ * - Copy/Paste support
+ * - Debug integration
+ * - Validation
+ */
+import type { SMState, SMTransition, SMLayer, SMParameter, SMDefinition, SMConditionGroup, SMCondition } from '../../ai/StateMachine';
+import type { Vec2 } from '../../core/types';
+import { SMEditorMode as _SMEditorMode, SMSelection, SMViewport, SMEditorConfig, SMPendingConnection, SMDebugState, SMEditorEvent, SMEditorEventType, SMValidationResult, SMSearchOptions, SMLayoutOptions, SMLayoutResult } from './types';
+export declare class StateMachineEditor {
+    private definition;
+    private activeLayerId;
+    private mode;
+    private selection;
+    private viewport;
+    private history;
+    private clipboard;
+    private config;
+    private pendingConnection;
+    private debugState;
+    private eventListeners;
+    private isDirty;
+    constructor(definition?: SMDefinition, config?: Partial<SMEditorConfig>);
+    private createEmptyDefinition;
+    private createDefaultLayer;
+    getDefinition(): SMDefinition;
+    setDefinition(definition: SMDefinition): void;
+    getActiveLayer(): SMLayer | null;
+    getActiveLayerId(): string | null;
+    setActiveLayer(layerId: string): void;
+    getLayers(): SMLayer[];
+    getLayer(layerId: string): SMLayer | null;
+    createLayer(name: string): SMLayer;
+    deleteLayer(layerId: string): boolean;
+    updateLayer(layerId: string, updates: Partial<SMLayer>): void;
+    getStates(layerId?: string): SMState[];
+    getState(stateId: string, layerId?: string): SMState | null;
+    createState(name: string, type?: SMState['type'], position?: Vec2, layerId?: string): SMState;
+    deleteState(stateId: string, layerId?: string): boolean;
+    updateState(stateId: string, updates: Partial<SMState>, layerId?: string): void;
+    moveState(stateId: string, position: Vec2, layerId?: string): void;
+    moveSelectedStates(delta: Vec2): void;
+    getTransitions(layerId?: string): SMTransition[];
+    getTransition(transitionId: string, layerId?: string): SMTransition | null;
+    createTransition(fromStateId: string, toStateId: string, name?: string, layerId?: string): SMTransition;
+    deleteTransition(transitionId: string, layerId?: string): boolean;
+    updateTransition(transitionId: string, updates: Partial<SMTransition>, layerId?: string): void;
+    addConditionGroup(transitionId: string, mode?: 'and' | 'or', layerId?: string): SMConditionGroup;
+    addCondition(transitionId: string, groupId: string, parameter: string, operator: SMCondition['operator'], value: boolean | number, layerId?: string): SMCondition;
+    removeCondition(transitionId: string, groupId: string, conditionId: string, layerId?: string): boolean;
+    getParameters(): SMParameter[];
+    getParameter(name: string): SMParameter | null;
+    createParameter(name: string, type: SMParameter['type'], value?: boolean | number): SMParameter;
+    deleteParameter(name: string): boolean;
+    updateParameter(name: string, updates: Partial<SMParameter>): void;
+    getSelection(): SMSelection;
+    isSelected(id: string): boolean;
+    selectState(stateId: string, addToSelection?: boolean): void;
+    selectTransition(transitionId: string, addToSelection?: boolean): void;
+    selectAll(): void;
+    deselectAll(): void;
+    selectInRect(rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): void;
+    deleteSelected(): void;
+    getMode(): _SMEditorMode;
+    setMode(mode: _SMEditorMode): void;
+    startConnection(fromStateId: string, fromPosition: Vec2): void;
+    updateConnection(toPosition: Vec2): void;
+    completeConnection(toStateId: string): SMTransition | null;
+    cancelConnection(): void;
+    getPendingConnection(): SMPendingConnection | null;
+    getViewport(): SMViewport;
+    setViewport(viewport: Partial<SMViewport>): void;
+    pan(delta: Vec2): void;
+    zoom(factor: number, center?: Vec2): void;
+    fitToContent(padding?: number): void;
+    resetViewport(): void;
+    private pushHistory;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    private applyUndoAction;
+    private applyRedoAction;
+    clearHistory(): void;
+    copy(): void;
+    cut(): void;
+    paste(offset?: Vec2): void;
+    duplicate(): void;
+    validate(): SMValidationResult;
+    private findReachableStates;
+    search(options: SMSearchOptions): Array<{
+        type: 'state' | 'transition' | 'parameter';
+        id: string;
+    }>;
+    autoLayout(options: SMLayoutOptions): SMLayoutResult;
+    private layoutHorizontal;
+    private layoutVertical;
+    private layoutTree;
+    private layoutRadial;
+    private layoutForceDirected;
+    getDebugState(): SMDebugState;
+    setDebugEnabled(enabled: boolean): void;
+    startPlayback(): void;
+    stopPlayback(): void;
+    pausePlayback(): void;
+    resumePlayback(): void;
+    addBreakpoint(id: string): void;
+    removeBreakpoint(id: string): void;
+    toggleBreakpoint(id: string): void;
+    hasBreakpoint(id: string): boolean;
+    on(event: SMEditorEventType, listener: (event: SMEditorEvent) => void): void;
+    off(event: SMEditorEventType, listener: (event: SMEditorEvent) => void): void;
+    private emit;
+    getConfig(): SMEditorConfig;
+    setConfig(config: Partial<SMEditorConfig>): void;
+    isDirtyState(): boolean;
+    markDirty(): void;
+    markClean(): void;
+    private generateId;
+    private snapToGrid;
+    private isPointInRect;
+    screenToWorld(screenPos: Vec2): Vec2;
+    worldToScreen(worldPos: Vec2): Vec2;
+}
+export declare function createStateMachineEditor(definition?: SMDefinition, config?: Partial<SMEditorConfig>): StateMachineEditor;

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

@@ -0,0 +1,11 @@
+/**
+ * @file state-machine/index.ts
+ * @description State Machine Editor exports
+ * PRO-1.4: Professional Editor Features
+ */
+export * from './types';
+export { StateMachineEditor, createStateMachineEditor } from './StateMachineEditor';
+export { SMEditorCanvas, createSMEditorCanvas } from './SMEditorCanvas';
+export type { SMEditorCanvasState } from './SMEditorCanvas';
+export { serializeStateMachine, deserializeStateMachine, downloadStateMachine, openStateMachineFile, toRuntimeDefinition, fromRuntimeDefinition, generateStateMachineTemplate, } from './serialization';
+export type { SMExportFormat, SMExportOptions } from './serialization';

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

@@ -0,0 +1,23 @@
+/**
+ * @file state-machine/serialization.ts
+ * @description Serialization utilities for State Machine Editor
+ * PRO-1.4: Professional Editor Features
+ */
+import type { SMDefinition } from '../../ai/StateMachine';
+export type SMExportFormat = 'json' | 'yaml' | 'typescript' | 'xml' | 'binary';
+export interface SMExportOptions {
+    format: SMExportFormat;
+    pretty: boolean;
+    includeMetadata: boolean;
+    includeEditorState: boolean;
+}
+export declare function serializeStateMachine(definition: SMDefinition, options?: Partial<SMExportOptions>): string;
+export declare function deserializeStateMachine(data: string, format?: SMExportFormat): SMDefinition;
+export declare function downloadStateMachine(definition: SMDefinition, filename: string, options?: Partial<SMExportOptions>): void;
+export declare function openStateMachineFile(): Promise<{
+    definition: SMDefinition;
+    filename: string;
+} | null>;
+export declare function toRuntimeDefinition(definition: SMDefinition): SMDefinition;
+export declare function fromRuntimeDefinition(runtime: SMDefinition): SMDefinition;
+export declare function generateStateMachineTemplate(type: 'simple' | 'character' | 'menu' | 'ai'): SMDefinition;