@nice2dev/game-engine 1.1.5 → 1.1.7

package/dist/types/visual-scripting/nodes/registerNodes.d.ts

@@ -0,0 +1,29 @@
+import './EventNodes';
+import './FlowControlNodes';
+import './MathNodes';
+import './LogicNodes';
+import './VariableNodes';
+import './ActionNodes';
+import './UtilityNodes';
+import type { NodeMetadata } from '../VisualScriptNode';
+/**
+ * Register all built-in nodes.
+ * Call this once at application startup.
+ */
+export declare function registerAllNodes(): void;
+/**
+ * Get a list of all registered node type IDs
+ */
+export declare function getRegisteredNodeTypes(): string[];
+/**
+ * Get all nodes organized by category
+ */
+export declare function getNodesByCategory(): Map<string, string[]>;
+/**
+ * Search for nodes by keyword
+ */
+export declare function searchNodes(query: string): string[];
+/**
+ * Get metadata for a node type
+ */
+export declare function getNodeMetadata(typeId: string): NodeMetadata | undefined;

package/dist/types/visual-scripting/types.d.ts

@@ -0,0 +1,402 @@
+/** Data types that can flow through pins */
+export type PinDataType = 'execution' | 'boolean' | 'number' | 'string' | 'vector2' | 'vector3' | 'color' | 'object' | 'entity' | 'component' | 'array' | 'any' | 'enum' | 'struct' | 'integer' | 'float' | 'vector4' | 'transform' | (string & {});
+/** Pin direction */
+export type PinDirection = 'input' | 'output';
+/** Pin definition */
+export interface PinDefinition {
+    /** Unique pin identifier within node */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Pin direction (optional in definitions; auto-set when used by addInputPin/addOutputPin) */
+    direction?: PinDirection;
+    /** Data type */
+    dataType: PinDataType;
+    /** For arrays, the element type */
+    elementType?: PinDataType;
+    /** For enums, the allowed values */
+    enumValues?: string[];
+    /** For structs, the struct definition name */
+    structType?: string;
+    /** Default value */
+    defaultValue?: unknown;
+    /** Is this pin required for execution? */
+    required?: boolean;
+    /** Can multiple connections attach to this pin? */
+    allowMultiple?: boolean;
+    /** Description/tooltip */
+    description?: string;
+    /** Is pin hidden in collapsed state? */
+    hiddenWhenCollapsed?: boolean;
+}
+/** Runtime pin instance */
+export interface Pin extends PinDefinition {
+    /** Pin direction (always set on runtime instances) */
+    direction: PinDirection;
+    /** Node this pin belongs to */
+    nodeId: string;
+    /** Current value (for inputs with defaults or outputs) */
+    value?: unknown;
+    /** Connected pins */
+    connections: PinConnection[];
+}
+/** Connection between two pins */
+export interface PinConnection {
+    /** Source node ID */
+    sourceNodeId: string;
+    /** Source pin ID */
+    sourcePinId: string;
+    /** Target node ID */
+    targetNodeId: string;
+    /** Target pin ID */
+    targetPinId: string;
+    /** Connection ID */
+    id: string;
+}
+/** Node category for organization. Built-in categories listed; custom strings allowed. */
+export type NodeCategory = 'event' | 'flow' | 'action' | 'function' | 'variable' | 'math' | 'logic' | 'conversion' | 'input' | 'physics' | 'audio' | 'debug' | 'custom' | (string & {});
+/** Node metadata */
+export interface NodeMetadata {
+    /** Unique node type identifier */
+    typeId: string;
+    /** Display name */
+    name: string;
+    /** Category */
+    category: NodeCategory;
+    /** Subcategory for organization */
+    subcategory?: string;
+    /** Description */
+    description: string;
+    /** Icon name or path */
+    icon?: string;
+    /** Color theme */
+    color?: string;
+    /** Keywords for search */
+    keywords?: string[];
+    /** Is this a pure function? (no execution pins) */
+    isPure?: boolean;
+    /** Is this node latent? (async execution) */
+    isLatent?: boolean;
+    /** Is this a development-only node? */
+    isDevOnly?: boolean;
+    /** Is this node deprecated? */
+    deprecated?: boolean;
+    /** Deprecation message */
+    deprecationMessage?: string;
+}
+/** Node instance state */
+export interface NodeState {
+    /** Instance ID */
+    id: string;
+    /** Node type */
+    typeId: string;
+    /** Position in graph */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Is node collapsed? */
+    collapsed?: boolean;
+    /** Comment/annotation */
+    comment?: string;
+    /** Breakpoint set? */
+    hasBreakpoint?: boolean;
+    /** Custom property values */
+    properties?: Record<string, unknown>;
+    /** Input pin values (defaults/overrides) */
+    inputValues?: Record<string, unknown>;
+}
+/** Visual script graph */
+export interface VisualScriptGraphData {
+    /** Graph ID */
+    id: string;
+    /** Graph name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Graph type */
+    type: 'event' | 'function' | 'macro';
+    /** All nodes in graph */
+    nodes: NodeState[];
+    /** All connections */
+    connections: PinConnection[];
+    /** Local variables */
+    variables: VariableDefinition[];
+    /** Graph-level comments/annotations */
+    comments: GraphComment[];
+    /** Subgraph references */
+    subgraphs?: string[];
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/** Variable definition */
+export interface VariableDefinition {
+    /** Variable ID */
+    id: string;
+    /** Variable name */
+    name: string;
+    /** Data type */
+    type: PinDataType;
+    /** Default value */
+    defaultValue?: unknown;
+    /** Is exposed to editor? */
+    exposed?: boolean;
+    /** Is read-only? */
+    readonly?: boolean;
+    /** Category for grouping */
+    category?: string;
+    /** Description */
+    description?: string;
+    /** For arrays */
+    elementType?: PinDataType;
+    /** For structs */
+    structType?: string;
+}
+/** Graph comment/annotation */
+export interface GraphComment {
+    /** Comment ID */
+    id: string;
+    /** Text content */
+    text: string;
+    /** Position */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Size */
+    size: {
+        width: number;
+        height: number;
+    };
+    /** Color */
+    color?: string;
+    /** Is it a group box? */
+    isGroup?: boolean;
+    /** Node IDs inside this group */
+    containedNodes?: string[];
+}
+/** Execution context for running scripts */
+export interface ExecutionContext {
+    /** Current entity */
+    entity?: unknown;
+    /** Current component */
+    component?: unknown;
+    /** Global variables */
+    globals: Map<string, unknown>;
+    /** Local variables */
+    locals: Map<string, unknown>;
+    /** Delta time */
+    deltaTime: number;
+    /** Total time */
+    totalTime: number;
+    /** Frame count */
+    frameCount: number;
+    /** Input state */
+    input?: InputState;
+    /** Physics world reference */
+    physics?: unknown;
+    /** Audio manager reference */
+    audio?: unknown;
+    /** Custom context data */
+    custom: Map<string, unknown>;
+}
+/** Input state for context */
+export interface InputState {
+    /** Currently pressed keys */
+    keys: Set<string>;
+    /** Keys pressed this frame */
+    keysDown: Set<string>;
+    /** Keys released this frame */
+    keysUp: Set<string>;
+    /** Mouse position */
+    mousePosition: {
+        x: number;
+        y: number;
+    };
+    /** Mouse buttons */
+    mouseButtons: {
+        left: boolean;
+        right: boolean;
+        middle: boolean;
+    };
+    /** Mouse buttons pressed this frame */
+    mouseDown: {
+        left: boolean;
+        right: boolean;
+        middle: boolean;
+    };
+    /** Mouse buttons released this frame */
+    mouseUp: {
+        left: boolean;
+        right: boolean;
+        middle: boolean;
+    };
+    /** Mouse wheel delta */
+    mouseWheel: number;
+    /** Gamepad state */
+    gamepads?: GamepadState[];
+    /** Touch points */
+    touches?: TouchPoint[];
+}
+/** Gamepad state */
+export interface GamepadState {
+    /** Gamepad index */
+    index: number;
+    /** Is connected */
+    connected: boolean;
+    /** Buttons */
+    buttons: boolean[];
+    /** Button pressed this frame */
+    buttonsDown: boolean[];
+    /** Axes values */
+    axes: number[];
+}
+/** Touch point */
+export interface TouchPoint {
+    /** Touch ID */
+    id: number;
+    /** Position */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Phase */
+    phase: 'began' | 'moved' | 'stationary' | 'ended' | 'cancelled';
+}
+/** Execution result */
+export interface ExecutionResult {
+    /** Was execution successful? */
+    success: boolean;
+    /** Output values */
+    outputs: Map<string, unknown>;
+    /** Error if failed */
+    error?: Error;
+    /** Execution path (for debugging) */
+    executionPath?: string[];
+    /** Execution time in ms */
+    executionTime?: number;
+}
+/** Debug mode */
+export type DebugMode = 'disabled' | 'step' | 'stepping' | 'breakpoints' | 'trace' | 'paused' | 'running';
+/** Alias for DebugMode */
+export type DebuggerMode = DebugMode;
+/** Breakpoint */
+export interface Breakpoint {
+    /** Graph ID */
+    graphId: string;
+    /** Node ID */
+    nodeId: string;
+    /** Is enabled? */
+    enabled: boolean;
+    /** Condition expression */
+    condition?: string;
+    /** Hit count trigger */
+    hitCount?: number;
+    /** Current hit count */
+    currentHits?: number;
+    /** Log message on hit */
+    logMessage?: string;
+}
+/** Debug event */
+export interface DebugEvent {
+    /** Event type */
+    type: 'node_enter' | 'node_exit' | 'breakpoint_hit' | 'error' | 'variable_change' | 'execution_start' | 'execution_end';
+    /** Timestamp */
+    timestamp: number;
+    /** Graph ID */
+    graphId: string;
+    /** Node ID (if applicable) */
+    nodeId?: string;
+    /** Variable name (if applicable) */
+    variableName?: string;
+    /** Old value */
+    oldValue?: unknown;
+    /** New value */
+    newValue?: unknown;
+    /** Error (if applicable) */
+    error?: Error;
+    /** Additional data */
+    data?: Record<string, unknown>;
+}
+/** Watch expression */
+export interface WatchExpression {
+    /** Expression ID */
+    id: string;
+    /** Expression text */
+    expression: string;
+    /** Current value */
+    value?: unknown;
+    /** Last error */
+    error?: string;
+}
+/** Debugger state */
+export interface DebuggerState {
+    /** Is debugging active */
+    active?: boolean;
+    /** Debug mode */
+    mode: DebugMode;
+    /** Is execution paused */
+    paused?: boolean;
+    /** Current node ID being debugged */
+    currentNodeId: string | null;
+    /** Breakpoints */
+    breakpoints: Breakpoint[];
+    /** Watch expressions (Map from id to expression) */
+    watches: Map<string, WatchExpression>;
+    /** Call stack */
+    callStack: CallStackFrame[];
+    /** Event history */
+    eventHistory?: DebugEvent[];
+    /** Max history size */
+    maxHistorySize?: number;
+}
+/** Call stack frame */
+export interface CallStackFrame {
+    /** Graph ID */
+    graphId: string;
+    /** Graph name */
+    graphName: string;
+    /** Current node ID */
+    nodeId: string;
+    /** Node name */
+    nodeName: string;
+    /** Local variables at this point */
+    locals: Map<string, unknown>;
+    /** Execution time in frame */
+    frameTime: number;
+}
+/** Visual script event */
+export type VisualScriptEvent = {
+    type: 'begin_play';
+} | {
+    type: 'tick';
+    deltaTime: number;
+} | {
+    type: 'end_play';
+} | {
+    type: 'collision_enter';
+    other: unknown;
+} | {
+    type: 'collision_exit';
+    other: unknown;
+} | {
+    type: 'trigger_enter';
+    other: unknown;
+} | {
+    type: 'trigger_exit';
+    other: unknown;
+} | {
+    type: 'input_action';
+    action: string;
+    value: number;
+} | {
+    type: 'custom';
+    name: string;
+    data: unknown;
+};
+/** Checks if two pin types can connect */
+export declare function canConnect(source: PinDataType, target: PinDataType): boolean;
+/** Get color for pin type */
+export declare function getPinColor(type: PinDataType): string;
+/** Get default value for type */
+export declare function getDefaultValue(type: PinDataType): unknown;