@directivegames/genesys.js 3.1.24

package/dist/src/navigation/RecastNavigationServer.js

@@ -0,0 +1,325 @@
+/**
+ * RecastNavigationServer integrates the `recast-navigation` library for AI pathfinding.
+ *
+ * It wraps Recast's navmesh generation and query APIs so actors can request
+ * paths or validate positions against the generated mesh. The server maintains
+ * a single navigation mesh and lazily creates query objects as needed. By
+ * centralizing this logic, the rest of the engine can issue navigation requests
+ * without importing Recast-specific types directly.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Feed a simplified THREE.Mesh into `createNavigationMesh` to build the navmesh.
+ * - Call `calculatePath` each frame an agent needs a new route.
+ * - Use `isPointOnNavigationMesh` or `getClosestPointOnNavigationMesh` before repositioning actors.
+ * - Remember to destroy the server when changing scenes to avoid memory leaks.
+ */
+import { DebugDrawer, threeToSoloNavMesh } from '@recast-navigation/three';
+import { exportNavMesh, importNavMesh, init, NavMesh, NavMeshQuery } from 'recast-navigation';
+import { generateSoloNavMesh } from 'recast-navigation/generators';
+import * as THREE from 'three';
+import { deinterleaveGeometry } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { NAVMESH_EXT } from '../const.js';
+import { projectInfo } from '../storage/projectContext.js';
+import { AssetPath } from '../storage/storageProvider.js';
+export class RecastNavigationServer {
+    constructor() {
+        // Set from NavigationOptions
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Runtime properties
+        Object.defineProperty(this, "navigationMesh", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "navMeshQuery", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    // TODO: use a proper type for this
+    static get DEFAULT_OPTIONS() {
+        return {
+            borderSize: 0,
+            cs: 1,
+            ch: 0.2,
+            walkableSlopeAngle: 35,
+            walkableHeight: 1,
+            walkableClimb: 1,
+            walkableRadius: 1,
+            maxEdgeLen: 12,
+            maxSimplificationError: 1.3,
+            minRegionArea: 8,
+            mergeRegionArea: 20,
+            maxVertsPerPoly: 6,
+            detailSampleDist: 6,
+            detailSampleMaxError: 1,
+        };
+    }
+    initialize(options) {
+        this.options = options.options;
+        return init().then(() => true);
+    }
+    destroy() {
+        // Properly dispose of WASM objects to free memory
+        if (this.navMeshQuery) {
+            this.navMeshQuery.destroy();
+            this.navMeshQuery = null;
+        }
+        if (this.navigationMesh) {
+            this.navigationMesh.destroy();
+            this.navigationMesh = null;
+        }
+    }
+    createNavigationMesh(mesh) {
+        const positions = mesh.geometry.attributes.position.array;
+        const indices = mesh.geometry.index?.array;
+        if (!positions) {
+            console.error('[RecastNavigationServer] createNavigationMesh failed: Positions could not be determined from mesh.');
+            return Promise.resolve(false);
+        }
+        if (!indices) {
+            console.error('[RecastNavigationServer] createNavigationMesh failed: Indices could not be determined from mesh.');
+            return Promise.resolve(false);
+        }
+        const result = generateSoloNavMesh(positions, indices, this.options);
+        this.setNavigationMesh(result.navMesh);
+        return Promise.resolve(true);
+    }
+    createNavigationMeshFromMeshes(meshes, overrideOptions) {
+        console.log(`[RecastNavigationServer] Creating navigation mesh from ${meshes.length} meshes ...`);
+        if (meshes.length === 0) {
+            console.warn('[RecastNavigationServer] No meshes provided for navigation mesh generation');
+            return Promise.resolve(false);
+        }
+        try {
+            // Deinterleave meshes before processing to ensure proper geometry formatting
+            const deinterleavedMeshes = this.deinterleaveMeshes(meshes);
+            const result = threeToSoloNavMesh(deinterleavedMeshes, overrideOptions ?? this.options);
+            if (result.success) {
+                this.setNavigationMesh(result.navMesh);
+                console.log('[RecastNavigationServer] Navigation mesh created successfully');
+            }
+            else {
+                const errorMessage = result.error || 'Unknown error during navigation mesh generation';
+                console.error('[RecastNavigationServer] threeToSoloNavMesh failed:', errorMessage);
+            }
+            return Promise.resolve(result.success);
+        }
+        catch (error) {
+            console.error('[RecastNavigationServer] Runtime error while creating navigation mesh:', error);
+            return Promise.resolve(false);
+        }
+    }
+    setNavigationMesh(navMesh) {
+        if (!navMesh) {
+            console.error('[RecastNavigationServer] setNavigationMesh: Navigation mesh not initialized');
+            return;
+        }
+        if (navMesh instanceof NavMesh) {
+            // Clean up previous instances to prevent memory leaks
+            if (this.navMeshQuery) {
+                this.navMeshQuery.destroy();
+                this.navMeshQuery = null;
+            }
+            if (this.navigationMesh) {
+                this.navigationMesh.destroy();
+                this.navigationMesh = null;
+            }
+            // Set new navigation mesh and create query instance
+            this.navigationMesh = navMesh;
+            this.navMeshQuery = new NavMeshQuery(this.navigationMesh);
+        }
+        else {
+            console.error('[RecastNavigationServer] setNavigationMesh: Navigation mesh is not a valid NavMesh instance');
+        }
+    }
+    /**
+     * Clear the current navigation mesh
+     */
+    clearNavigationMesh() {
+        console.log('[RecastNavigationServer] clearNavigationMesh: Clearing current navigation mesh');
+        // Clean up previous instances to prevent memory leaks
+        if (this.navMeshQuery) {
+            this.navMeshQuery.destroy();
+            this.navMeshQuery = null;
+        }
+        if (this.navigationMesh) {
+            this.navigationMesh.destroy();
+            this.navigationMesh = null;
+        }
+    }
+    /**
+     * Deinterleaves mesh geometry data only if it actually has interleaved buffer attributes.
+     * Uses the proper deinterleaveGeometry utility that checks for InterleavedBufferAttribute.
+     * @param meshes Array of THREE.Mesh objects to potentially deinterleave
+     * @returns Array of meshes with deinterleaved geometry data where needed
+     */
+    deinterleaveMeshes(meshes) {
+        return meshes.map(mesh => {
+            // Clone geometry first since deinterleaveGeometry modifies in-place
+            const clonedGeometry = mesh.geometry.clone();
+            deinterleaveGeometry(clonedGeometry);
+            // Just replace the geometry on the existing mesh
+            mesh.geometry = clonedGeometry;
+            return mesh;
+        });
+    }
+    calculatePath(start, end) {
+        if (!this.navigationMesh || !this.navMeshQuery) {
+            console.error('[RecastNavigationServer] calculatePath: Navigation mesh not initialized');
+            return [];
+        }
+        const startInfo = this.navMeshQuery.findNearestPoly(start);
+        const endInfo = this.navMeshQuery.findNearestPoly(end);
+        const pathResult = this.navMeshQuery.computePath(startInfo.nearestPoint, endInfo.nearestPoint);
+        return pathResult.path.map(point => new THREE.Vector3(point.x, point.y, point.z));
+    }
+    /**
+     * Checks if a point is on the navigation mesh
+     * @param point The point to check
+     * @returns True if the point is on the navigation mesh, false otherwise
+     */
+    isPointOnNavigationMesh(point) {
+        if (!this.navigationMesh || !this.navMeshQuery) {
+            console.error('[RecastNavigationServer] isPointOnNavigationMesh: Navigation mesh not initialized');
+            return false;
+        }
+        const result = this.navMeshQuery.findNearestPoly(point);
+        // Check if a valid polygon reference was found
+        // and if the point is directly over that polygon (isOverPoly property)
+        if (result.nearestRef && result.isOverPoly) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Gets the closest point on the navigation mesh to the specified point
+     * @param point The reference point
+     * @returns The closest point on the navigation mesh, or the original point if the navigation mesh is not initialized
+     */
+    getClosestPointOnNavigationMesh(point) {
+        if (!this.navigationMesh || !this.navMeshQuery) {
+            console.error('[RecastNavigationServer] getClosestPointOnNavigationMesh: Navigation mesh not initialized');
+            return point.clone();
+        }
+        const result = this.navMeshQuery.findNearestPoly(point);
+        if (result.nearestPoint) {
+            return new THREE.Vector3(result.nearestPoint.x, result.nearestPoint.y, result.nearestPoint.z);
+        }
+        // If no nearest point could be found, return the original point
+        return point.clone();
+    }
+    /**
+     * Create debug visualization for the navigation mesh
+     * @returns A DebugDrawer instance that can be added to the scene, or null if no navigation mesh exists
+     */
+    createDebugVisualization() {
+        if (!this.navigationMesh) {
+            console.warn('[RecastNavigationServer] createDebugVisualization: No navigation mesh available');
+            return null;
+        }
+        try {
+            const debugDrawer = new DebugDrawer();
+            debugDrawer.drawNavMesh(this.navigationMesh, 0);
+            return debugDrawer;
+        }
+        catch (error) {
+            console.error('[RecastNavigationServer] createDebugVisualization: Failed to create debug visualization:', error);
+            return null;
+        }
+    }
+    /**
+     * Export the current navigation mesh to a binary file
+     * @param scenePath The path to the scene file (used to determine navmesh file path)
+     * @returns Promise resolving to export result with data and filename
+     */
+    async exportNavigationMesh(scenePath) {
+        if (!this.navigationMesh) {
+            console.error('[RecastNavigationServer] exportNavigationMesh: No navigation mesh available');
+            return { success: false };
+        }
+        try {
+            // Use the proper recast-navigation exportNavMesh function
+            const navMeshData = exportNavMesh(this.navigationMesh);
+            console.log('[RecastNavigationServer] exportNavigationMesh: NavMesh serialized');
+            console.log('  Data size:', navMeshData.length, 'bytes');
+            // Determine filename - basing it off the scene path minus the scene extension
+            const filename = `${scenePath.initialPath.split('/').pop()?.replace(/\.[^.]+$/, '') ?? 'navmesh'}${NAVMESH_EXT}`;
+            // Convert Uint8Array to ArrayBuffer for consistency with other export APIs
+            // Ensure we return ArrayBuffer, not SharedArrayBuffer by creating a new buffer
+            const arrayBuffer = new ArrayBuffer(navMeshData.length);
+            new Uint8Array(arrayBuffer).set(navMeshData);
+            console.log(`[RecastNavigationServer] exportNavigationMesh: NavMesh data prepared for export as ${filename}`);
+            return { success: true, data: arrayBuffer, filename };
+        }
+        catch (error) {
+            console.error('[RecastNavigationServer] exportNavigationMesh: Export failed:', error);
+            return { success: false };
+        }
+    }
+    /**
+     * Import a navigation mesh from a binary file
+     * @param scenePath The path to the scene file (used to determine navmesh file path)
+     * @returns Promise resolving to success/failure
+     */
+    async importNavigationMesh(scenePath) {
+        try {
+            // Determine input path basing it off the scene path minus the scene extension
+            const pathWithoutExt = scenePath.initialPath.replace(/\.[^.]+$/, '');
+            const navmeshPath = `${pathWithoutExt}${NAVMESH_EXT}`;
+            // Load the NavMesh file
+            const provider = projectInfo.storageProvider;
+            if (!provider) {
+                console.error('[RecastNavigationServer] importNavigationMesh: No storage provider available');
+                return false;
+            }
+            const navMeshBuffer = await provider.downloadFileAsBuffer(new AssetPath(navmeshPath));
+            // Use the data-based import method
+            return await this.importNavigationMeshFromData(navMeshBuffer);
+        }
+        catch (error) {
+            console.error('[RecastNavigationServer] importNavigationMesh: Import failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Import a navigation mesh from NavMesh data directly
+     * @param navMeshData The NavMesh data as ArrayBuffer (from recast-navigation export)
+     * @returns Promise resolving to success/failure
+     */
+    async importNavigationMeshFromData(navMeshData) {
+        try {
+            // Convert ArrayBuffer to Uint8Array for recast-navigation
+            const uint8Array = new Uint8Array(navMeshData);
+            console.log('[RecastNavigationServer] importNavigationMeshFromData: NavMesh data received');
+            console.log('  Data size:', uint8Array.length, 'bytes');
+            // Use the proper recast-navigation importNavMesh function
+            const result = importNavMesh(uint8Array);
+            if (!result || !result.navMesh) {
+                console.error('[RecastNavigationServer] importNavigationMeshFromData: Failed to import navigation mesh');
+                console.error('  importNavMesh result:', result);
+                return false;
+            }
+            // Set the new navigation mesh
+            this.navigationMesh = result.navMesh;
+            console.log('[RecastNavigationServer] Navigation mesh imported from data successfully');
+            return true;
+        }
+        catch (error) {
+            console.error('[RecastNavigationServer] importNavigationMeshFromData: Import failed:', error);
+            return false;
+        }
+    }
+    isReady() {
+        return this.navigationMesh !== null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RecastNavigationServer.js","sourceRoot":"","sources":["../../../src/navigation/RecastNavigationServer.ts"],"names":[],"mappings":"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"}

package/dist/src/navigation/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Navigation entry point aggregating available navigation servers.
+ *
+ * This barrel file groups the various navigation exports so other modules can
+ * import from a single path. It currently exposes the generic server interface
+ * along with the Recast implementation but can be expanded as new backends are
+ * added to the engine.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Import `createNavigationServer` and related types from this folder rather
+ *   than individual files.
+ * - Add additional exports here when integrating alternative navigation
+ *   solutions to keep the public API consistent.
+ */
+export * from './NavigationServer.js';
+export * from './RecastNavigationServer.js';

package/dist/src/navigation/index.js

@@ -0,0 +1,17 @@
+/**
+ * Navigation entry point aggregating available navigation servers.
+ *
+ * This barrel file groups the various navigation exports so other modules can
+ * import from a single path. It currently exposes the generic server interface
+ * along with the Recast implementation but can be expanded as new backends are
+ * added to the engine.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Import `createNavigationServer` and related types from this folder rather
+ *   than individual files.
+ * - Add additional exports here when integrating alternative navigation
+ *   solutions to keep the public API consistent.
+ */
+export * from './NavigationServer.js';
+export * from './RecastNavigationServer.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbmF2aWdhdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7OztHQWFHO0FBQ0gsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDZCQUE2QixDQUFDIn0=

package/dist/src/npc/behavior-tree/BehaviorNode.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Base class for all behavior tree nodes.
+ *
+ * Behavior trees are hierarchical structures that control AI decision making.
+ * Each node returns a status (Success, Failure, Running) when executed.
+ * Nodes can be Composite (have children), Decorator (modify child behavior),
+ * or Leaf (perform actions or check conditions).
+ *
+ * Nodes can have attached conditions that control whether they execute,
+ * similar to Unreal Engine's behavior tree decorators.
+ */
+import type { ConditionEvaluator } from './behaviors/ConditionEvaluator.js';
+import type { Blackboard } from './blackboard/Blackboard.js';
+export declare enum BehaviorStatus {
+    Success = "Success",
+    Failure = "Failure",
+    Running = "Running"
+}
+export interface BehaviorNodeOptions {
+    name?: string;
+    description?: string;
+    /** Conditions that must be met for this node to execute */
+    conditions?: ConditionEvaluator[];
+}
+export declare abstract class BehaviorNode {
+    readonly name: string;
+    readonly description: string;
+    protected isInitialized: boolean;
+    protected conditions: ConditionEvaluator[];
+    protected currentStatus: BehaviorStatus;
+    protected isCurrentlyExecuting: boolean;
+    constructor(options?: BehaviorNodeOptions);
+    /**
+     * Initialize the node. Called once before first execution.
+     */
+    initialize(blackboard: Blackboard): void;
+    /**
+     * Execute the node's behavior.
+     * @param blackboard Shared memory for the behavior tree
+     * @param deltaTime Time elapsed since last frame in seconds
+     * @returns Promise resolving to the execution status
+     */
+    execute(blackboard: Blackboard, deltaTime: number): Promise<BehaviorStatus>;
+    /**
+     * Reset the node to its initial state.
+     * Called when the node needs to be restarted.
+     */
+    reset(): void;
+    /**
+     * Clean up resources when the node is destroyed.
+     */
+    destroy(): void;
+    /**
+     * Override to implement initialization logic.
+     */
+    protected onInitialize(blackboard: Blackboard): void;
+    /**
+     * Override to implement the node's main behavior.
+     */
+    protected abstract onExecute(blackboard: Blackboard, deltaTime: number): Promise<BehaviorStatus>;
+    /**
+     * Override to implement reset logic.
+     */
+    protected onReset(): void;
+    /**
+     * Override to implement cleanup logic.
+     */
+    protected onDestroy(): void;
+    /**
+     * Get debug information about this node.
+     */
+    getDebugInfo(): {
+        name: string;
+        description: string;
+        status: string;
+        isExecuting: boolean;
+    };
+    /**
+     * Check if this node is currently executing
+     */
+    isExecuting(): boolean;
+    /**
+     * Get the current status of this node
+     */
+    getStatus(): BehaviorStatus;
+    /**
+     * Get the currently executing child node (for composite nodes)
+     * Override in composite nodes to provide child execution info
+     */
+    getCurrentlyExecutingChild(): BehaviorNode | null;
+    /**
+     * Get the full execution path from this node down to the currently executing leaf
+     */
+    getExecutionPath(): BehaviorNode[];
+}

package/dist/src/npc/behavior-tree/BehaviorNode.js

@@ -0,0 +1,177 @@
+export var BehaviorStatus;
+(function (BehaviorStatus) {
+    BehaviorStatus["Success"] = "Success";
+    BehaviorStatus["Failure"] = "Failure";
+    BehaviorStatus["Running"] = "Running";
+})(BehaviorStatus || (BehaviorStatus = {}));
+export class BehaviorNode {
+    constructor(options = {}) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "conditions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "currentStatus", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: BehaviorStatus.Success
+        });
+        Object.defineProperty(this, "isCurrentlyExecuting", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.name = options.name ?? this.constructor.name;
+        this.description = options.description ?? '';
+        this.conditions = options.conditions ?? [];
+    }
+    /**
+     * Initialize the node. Called once before first execution.
+     */
+    initialize(blackboard) {
+        if (!this.isInitialized) {
+            // Initialize attached conditions
+            for (const condition of this.conditions) {
+                condition.initialize(blackboard);
+            }
+            this.onInitialize(blackboard);
+            this.isInitialized = true;
+        }
+    }
+    /**
+     * Execute the node's behavior.
+     * @param blackboard Shared memory for the behavior tree
+     * @param deltaTime Time elapsed since last frame in seconds
+     * @returns Promise resolving to the execution status
+     */
+    async execute(blackboard, deltaTime) {
+        if (!this.isInitialized) {
+            this.initialize(blackboard);
+        }
+        // Mark as currently executing
+        this.isCurrentlyExecuting = true;
+        try {
+            // Check attached conditions first
+            for (const condition of this.conditions) {
+                const conditionResult = await condition.evaluate(blackboard);
+                if (conditionResult !== BehaviorStatus.Success) {
+                    // Condition failed, node cannot execute
+                    this.currentStatus = BehaviorStatus.Failure;
+                    return this.currentStatus;
+                }
+            }
+            // All conditions passed, execute the node
+            this.currentStatus = await this.onExecute(blackboard, deltaTime);
+            return this.currentStatus;
+        }
+        finally {
+            // Mark as no longer executing if not running
+            if (this.currentStatus !== BehaviorStatus.Running) {
+                this.isCurrentlyExecuting = false;
+            }
+        }
+    }
+    /**
+     * Reset the node to its initial state.
+     * Called when the node needs to be restarted.
+     */
+    reset() {
+        this.isCurrentlyExecuting = false;
+        this.currentStatus = BehaviorStatus.Success;
+        // Reset attached conditions
+        for (const condition of this.conditions) {
+            condition.reset();
+        }
+        this.onReset();
+    }
+    /**
+     * Clean up resources when the node is destroyed.
+     */
+    destroy() {
+        this.onDestroy();
+    }
+    /**
+     * Override to implement initialization logic.
+     */
+    onInitialize(blackboard) {
+        // Default implementation does nothing
+    }
+    /**
+     * Override to implement reset logic.
+     */
+    onReset() {
+        // Default implementation does nothing
+    }
+    /**
+     * Override to implement cleanup logic.
+     */
+    onDestroy() {
+        // Default implementation does nothing
+    }
+    /**
+     * Get debug information about this node.
+     */
+    getDebugInfo() {
+        return {
+            name: this.name,
+            description: this.description,
+            status: this.currentStatus,
+            isExecuting: this.isCurrentlyExecuting
+        };
+    }
+    /**
+     * Check if this node is currently executing
+     */
+    isExecuting() {
+        return this.isCurrentlyExecuting;
+    }
+    /**
+     * Get the current status of this node
+     */
+    getStatus() {
+        return this.currentStatus;
+    }
+    /**
+     * Get the currently executing child node (for composite nodes)
+     * Override in composite nodes to provide child execution info
+     */
+    getCurrentlyExecutingChild() {
+        return null;
+    }
+    /**
+     * Get the full execution path from this node down to the currently executing leaf
+     */
+    getExecutionPath() {
+        const path = [];
+        if (this.isCurrentlyExecuting) {
+            path.push(this);
+            const currentChild = this.getCurrentlyExecutingChild();
+            if (currentChild) {
+                path.push(...currentChild.getExecutionPath());
+            }
+        }
+        return path;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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