@directivegames/genesys.js 3.1.24

package/dist/src/npc/behavior-tree/behaviors/actions/utility/CalculateTacticalPositionAction.js

@@ -0,0 +1,123 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import * as THREE from 'three';
+import { EngineClass } from '../../../../../systems/ClassRegistry.js';
+import { BehaviorStatus } from '../../../BehaviorNode.js';
+import { BehaviorAction } from '../../BehaviorAction.js';
+/**
+ * Action that calculates a tactical position at a specified distance from a target actor.
+ * This is useful for positioning NPCs at optimal combat ranges or flanking positions.
+ */
+let CalculateTacticalPositionAction = class CalculateTacticalPositionAction extends BehaviorAction {
+    constructor(options = {}) {
+        super({
+            name: 'CalculateTacticalPosition',
+            ...options
+        });
+        Object.defineProperty(this, "targetActorKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "outputPositionKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "distance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "useNavigation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "angleOffset", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.targetActorKey = options.targetActorKey ?? 'PlayerActor';
+        this.outputPositionKey = options.outputPositionKey ?? 'TacticalPosition';
+        this.distance = options.distance ?? 25.0;
+        this.useNavigation = options.useNavigation ?? true;
+        this.angleOffset = options.angleOffset ?? 0;
+    }
+    onInitialize(blackboard) {
+        // Nothing to initialize
+    }
+    onEnter(blackboard) {
+        // Calculate position immediately on enter
+        this.calculateTacticalPosition(blackboard);
+    }
+    async onUpdate(blackboard, deltaTime) {
+        // This action completes immediately after calculating the position
+        return BehaviorStatus.Success;
+    }
+    onExit(blackboard, status) {
+        // Nothing to clean up
+    }
+    calculateTacticalPosition(blackboard) {
+        const owner = this.getOwner(blackboard);
+        if (!owner) {
+            return;
+        }
+        // Get target actor
+        const targetActor = blackboard.getValue(this.targetActorKey);
+        if (!targetActor) {
+            console.warn(`CalculateTacticalPositionAction: No target actor found with key ${this.targetActorKey}`);
+            return;
+        }
+        // Get current positions
+        const ownerPosition = new THREE.Vector3();
+        const targetPosition = new THREE.Vector3();
+        owner.rootComponent.getWorldPosition(ownerPosition);
+        targetActor.rootComponent.getWorldPosition(targetPosition);
+        // Calculate direction from target to owner
+        const directionToOwner = ownerPosition.clone().sub(targetPosition);
+        directionToOwner.y = 0; // Keep on same height level
+        directionToOwner.normalize();
+        // Apply angle offset if specified
+        if (this.angleOffset !== 0) {
+            const rotationMatrix = new THREE.Matrix4().makeRotationY(this.angleOffset);
+            directionToOwner.applyMatrix4(rotationMatrix);
+        }
+        // Calculate tactical position at the desired distance
+        const tacticalPosition = targetPosition.clone().add(directionToOwner.multiplyScalar(this.distance));
+        // If using navigation, find the closest valid point on the navigation mesh
+        if (this.useNavigation) {
+            const world = owner.getWorld();
+            const navigationServer = world?.getNavigationServer();
+            if (navigationServer && navigationServer.isReady()) {
+                const validPosition = navigationServer.getClosestPointOnNavigationMesh(tacticalPosition);
+                blackboard.setValue(this.outputPositionKey, validPosition);
+                return;
+            }
+            else {
+                return;
+            }
+        }
+        // Store the calculated position in the blackboard
+        blackboard.setValue(this.outputPositionKey, tacticalPosition);
+    }
+};
+CalculateTacticalPositionAction = __decorate([
+    EngineClass('CalculateTacticalPositionAction'),
+    __metadata("design:paramtypes", [Object])
+], CalculateTacticalPositionAction);
+export { CalculateTacticalPositionAction };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/npc/behavior-tree/behaviors/actions/utility/LookAtTargetAction.d.ts

@@ -0,0 +1,43 @@
+import { BehaviorStatus } from '../../../BehaviorNode.js';
+import { BehaviorAction, type BehaviorActionOptions } from '../../BehaviorAction.js';
+import type { Blackboard } from '../../../blackboard/Blackboard.js';
+export interface LookAtTargetActionOptions extends BehaviorActionOptions {
+    /** Blackboard key containing the target actor to look at */
+    targetActorKey?: string;
+    /** Blackboard key containing the target position to look at */
+    targetPositionKey?: string;
+    /** Angle threshold in radians for considering the look complete */
+    angleThreshold?: number;
+    /** Rotation speed in radians per second */
+    rotationSpeed?: number;
+    /**
+     * Whether to only rotate in the XZ plane (horizontal only) or allow full XYZ rotation.
+     * - true: Only rotate around Y-axis (XZ plane) - good for ground-based characters
+     * - false: Allow full XYZ rotation - good for flying/aerial characters
+     */
+    horizontalOnly?: boolean;
+    /** Speed multiplier for rotation (higher = faster rotation) */
+    speed?: number;
+}
+/**
+ * Action that makes the NPC look at a target actor or position.
+ * Rotates the actor's forward direction to point towards the target.
+ *
+ * Supports two rotation modes:
+ * - XZ plane only (horizontalOnly: true): Rotates only around Y-axis, good for ground characters
+ * - Full XYZ rotation (horizontalOnly: false): Allows pitch/yaw rotation, good for aerial characters
+ */
+export declare class LookAtTargetAction extends BehaviorAction {
+    private targetActorKey?;
+    private targetPositionKey?;
+    private angleThreshold;
+    private rotationSpeed;
+    private horizontalOnly;
+    private speed;
+    constructor(options?: LookAtTargetActionOptions);
+    protected onInitialize(blackboard: Blackboard): void;
+    protected onEnter(blackboard: Blackboard): void;
+    protected onUpdate(blackboard: Blackboard, deltaTime: number): Promise<BehaviorStatus>;
+    protected onExit(blackboard: Blackboard, status: BehaviorStatus): void;
+    private getTargetPosition;
+}

package/dist/src/npc/behavior-tree/behaviors/actions/utility/LookAtTargetAction.js

@@ -0,0 +1,140 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import * as THREE from 'three';
+import { AerialMovementComponent } from '../../../../../components/movement/AerialMovementComponent.js';
+import { NpcMovementComponent } from '../../../../../components/movement/NpcMovementComponent.js';
+import { EngineClass } from '../../../../../systems/ClassRegistry.js';
+import { BehaviorStatus } from '../../../BehaviorNode.js';
+import { BehaviorAction } from '../../BehaviorAction.js';
+/**
+ * Action that makes the NPC look at a target actor or position.
+ * Rotates the actor's forward direction to point towards the target.
+ *
+ * Supports two rotation modes:
+ * - XZ plane only (horizontalOnly: true): Rotates only around Y-axis, good for ground characters
+ * - Full XYZ rotation (horizontalOnly: false): Allows pitch/yaw rotation, good for aerial characters
+ */
+let LookAtTargetAction = class LookAtTargetAction extends BehaviorAction {
+    constructor(options = {}) {
+        super({
+            name: 'LookAt',
+            ...options
+        });
+        Object.defineProperty(this, "targetActorKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "targetPositionKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "angleThreshold", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "rotationSpeed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "horizontalOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "speed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.targetActorKey = options.targetActorKey ?? 'PlayerActor';
+        this.targetPositionKey = options.targetPositionKey;
+        this.angleThreshold = options.angleThreshold ?? Math.PI / 16; // ~11.25 degrees
+        this.rotationSpeed = options.rotationSpeed ?? 3.0; // radians per second
+        this.horizontalOnly = options.horizontalOnly ?? true;
+        this.speed = options.speed ?? 1.0;
+    }
+    onInitialize(blackboard) {
+        // No initialization needed - we work directly with the actor's transform
+    }
+    onEnter(blackboard) {
+        // No setup needed - deltaTime is now provided directly
+    }
+    async onUpdate(blackboard, deltaTime) {
+        const owner = this.getOwner(blackboard);
+        if (!owner) {
+            return BehaviorStatus.Failure;
+        }
+        // Get target position
+        const targetPos = this.getTargetPosition(blackboard);
+        if (!targetPos) {
+            return BehaviorStatus.Failure;
+        }
+        // Try to get either type of movement component
+        const npcMovementComponent = owner.getComponent(NpcMovementComponent);
+        const aerialMovementComponent = owner.getComponent(AerialMovementComponent);
+        const movementComponent = npcMovementComponent ?? aerialMovementComponent;
+        if (!movementComponent) {
+            return BehaviorStatus.Failure;
+        }
+        // Set the look-at target on the movement component (both have same API)
+        movementComponent.setLookAtTarget(targetPos, this.angleThreshold);
+        // Check if we're done looking at the target (both have same API)
+        if (movementComponent.isLookingAtTargetComplete()) {
+            return BehaviorStatus.Success;
+        }
+        return BehaviorStatus.Running;
+    }
+    onExit(blackboard, status) {
+        const owner = this.getOwner(blackboard);
+        if (owner) {
+            // Try to get either type of movement component
+            const npcMovementComponent = owner.getComponent(NpcMovementComponent);
+            const aerialMovementComponent = owner.getComponent(AerialMovementComponent);
+            const movementComponent = npcMovementComponent ?? aerialMovementComponent;
+            if (movementComponent) {
+                // Clear the look-at target when exiting (both have same API)
+                movementComponent.clearLookAtTarget();
+            }
+        }
+    }
+    getTargetPosition(blackboard) {
+        if (this.targetActorKey) {
+            const actor = blackboard.getValue(this.targetActorKey);
+            if (actor) {
+                const position = new THREE.Vector3();
+                actor.rootComponent.getWorldPosition(position);
+                return position;
+            }
+        }
+        if (this.targetPositionKey) {
+            const position = blackboard.getValue(this.targetPositionKey);
+            if (position) {
+                return position.clone();
+            }
+        }
+        return null;
+    }
+};
+LookAtTargetAction = __decorate([
+    EngineClass('LookAtTargetAction'),
+    __metadata("design:paramtypes", [Object])
+], LookAtTargetAction);
+export { LookAtTargetAction };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/npc/behavior-tree/behaviors/actions/utility/WaitAction.d.ts

@@ -0,0 +1,24 @@
+import { BehaviorStatus } from '../../../BehaviorNode.js';
+import { BehaviorAction, type BehaviorActionOptions } from '../../BehaviorAction.js';
+import type { Blackboard } from '../../../blackboard/Blackboard.js';
+export interface WaitActionOptions extends BehaviorActionOptions {
+    /** Duration to wait in seconds */
+    duration?: number;
+    /** Whether to use random duration between 0 and duration */
+    randomDuration?: boolean;
+}
+/**
+ * Atomic action that waits for a specified duration before completing.
+ * Useful for timing behaviors, pauses, and creating delays in behavior sequences.
+ */
+export declare class WaitAction extends BehaviorAction {
+    private duration;
+    private randomDuration;
+    private startTime;
+    private waitDuration;
+    constructor(options?: WaitActionOptions);
+    protected onInitialize(blackboard: Blackboard): void;
+    protected onEnter(blackboard: Blackboard): void;
+    protected onUpdate(blackboard: Blackboard, deltaTime: number): Promise<BehaviorStatus>;
+    protected onExit(blackboard: Blackboard, status: BehaviorStatus): void;
+}

package/dist/src/npc/behavior-tree/behaviors/actions/utility/WaitAction.js

@@ -0,0 +1,85 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { EngineClass } from '../../../../../systems/ClassRegistry.js';
+import { BehaviorStatus } from '../../../BehaviorNode.js';
+import { BehaviorAction } from '../../BehaviorAction.js';
+/**
+ * Atomic action that waits for a specified duration before completing.
+ * Useful for timing behaviors, pauses, and creating delays in behavior sequences.
+ */
+let WaitAction = class WaitAction extends BehaviorAction {
+    constructor(options = {}) {
+        super({
+            name: 'Wait',
+            ...options
+        });
+        Object.defineProperty(this, "duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "randomDuration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "startTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "waitDuration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.duration = options.duration ?? 1.0;
+        this.randomDuration = options.randomDuration ?? false;
+    }
+    onInitialize(blackboard) {
+        // No initialization needed for wait action
+    }
+    onEnter(blackboard) {
+        // Use configured duration directly
+        const targetDuration = this.duration;
+        // Apply randomization if enabled
+        if (this.randomDuration) {
+            this.waitDuration = Math.random() * targetDuration;
+        }
+        else {
+            this.waitDuration = targetDuration;
+        }
+        // Record start time
+        this.startTime = Date.now() / 1000; // Convert to seconds
+    }
+    async onUpdate(blackboard, deltaTime) {
+        const currentTime = Date.now() / 1000; // Convert to seconds
+        const elapsedTime = currentTime - this.startTime;
+        // Check if wait duration has elapsed
+        if (elapsedTime >= this.waitDuration) {
+            return BehaviorStatus.Success;
+        }
+        // Still waiting
+        return BehaviorStatus.Running;
+    }
+    onExit(blackboard, status) {
+        // Clean up if needed
+    }
+};
+WaitAction = __decorate([
+    EngineClass('WaitAction'),
+    __metadata("design:paramtypes", [Object])
+], WaitAction);
+export { WaitAction };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV2FpdEFjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9ucGMvYmVoYXZpb3ItdHJlZS9iZWhhdmlvcnMvYWN0aW9ucy91dGlsaXR5L1dhaXRBY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBQ3RFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUMxRCxPQUFPLEVBQUUsY0FBYyxFQUE4QixNQUFNLHlCQUF5QixDQUFDO0FBV3JGOzs7R0FHRztBQUVJLElBQU0sVUFBVSxHQUFoQixNQUFNLFVBQVcsU0FBUSxjQUFjO0lBTTVDLFlBQVksVUFBNkIsRUFBRTtRQUN6QyxLQUFLLENBQUM7WUFDSixJQUFJLEVBQUUsTUFBTTtZQUNaLEdBQUcsT0FBTztTQUNYLENBQUMsQ0FBQztRQVRHOzs7OztXQUFpQjtRQUNqQjs7Ozs7V0FBd0I7UUFDeEI7Ozs7bUJBQW9CLENBQUM7V0FBQztRQUN0Qjs7OzttQkFBdUIsQ0FBQztXQUFDO1FBUS9CLElBQUksQ0FBQyxRQUFRLEdBQUcsT0FBTyxDQUFDLFFBQVEsSUFBSSxHQUFHLENBQUM7UUFDeEMsSUFBSSxDQUFDLGNBQWMsR0FBRyxPQUFPLENBQUMsY0FBYyxJQUFJLEtBQUssQ0FBQztJQUN4RCxDQUFDO0lBRWtCLFlBQVksQ0FBQyxVQUFzQjtRQUNwRCwyQ0FBMkM7SUFDN0MsQ0FBQztJQUVrQixPQUFPLENBQUMsVUFBc0I7UUFDL0MsbUNBQW1DO1FBQ25DLE1BQU0sY0FBYyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUM7UUFFckMsaUNBQWlDO1FBQ2pDLElBQUksSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO1lBQ3hCLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLE1BQU0sRUFBRSxHQUFHLGNBQWMsQ0FBQztRQUNyRCxDQUFDO2FBQU0sQ0FBQztZQUNOLElBQUksQ0FBQyxZQUFZLEdBQUcsY0FBYyxDQUFDO1FBQ3JDLENBQUM7UUFFRCxvQkFBb0I7UUFDcEIsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLENBQUMscUJBQXFCO0lBQzNELENBQUM7SUFFa0IsS0FBSyxDQUFDLFFBQVEsQ0FBQyxVQUFzQixFQUFFLFNBQWlCO1FBQ3pFLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUMsQ0FBQyxxQkFBcUI7UUFDNUQsTUFBTSxXQUFXLEdBQUcsV0FBVyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUM7UUFFakQscUNBQXFDO1FBQ3JDLElBQUksV0FBVyxJQUFJLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUNyQyxPQUFPLGNBQWMsQ0FBQyxPQUFPLENBQUM7UUFDaEMsQ0FBQztRQUVELGdCQUFnQjtRQUNoQixPQUFPLGNBQWMsQ0FBQyxPQUFPLENBQUM7SUFDaEMsQ0FBQztJQUVrQixNQUFNLENBQUMsVUFBc0IsRUFBRSxNQUFzQjtRQUN0RSxxQkFBcUI7SUFDdkIsQ0FBQztDQUNGLENBQUE7QUFuRFksVUFBVTtJQUR0QixXQUFXLENBQUMsWUFBWSxDQUFDOztHQUNiLFVBQVUsQ0FtRHRCIn0=

package/dist/src/npc/behavior-tree/behaviors/actions/utility/index.d.ts

@@ -0,0 +1,3 @@
+export { WaitAction, type WaitActionOptions } from './WaitAction.js';
+export { LookAtTargetAction, type LookAtTargetActionOptions } from './LookAtTargetAction.js';
+export { CalculateTacticalPositionAction, type CalculateTacticalPositionActionOptions } from './CalculateTacticalPositionAction.js';

package/dist/src/npc/behavior-tree/behaviors/actions/utility/index.js

@@ -0,0 +1,5 @@
+// Utility actions (timing, waiting, and general purpose actions)
+export { WaitAction } from './WaitAction.js';
+export { LookAtTargetAction } from './LookAtTargetAction.js';
+export { CalculateTacticalPositionAction } from './CalculateTacticalPositionAction.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbnBjL2JlaGF2aW9yLXRyZWUvYmVoYXZpb3JzL2FjdGlvbnMvdXRpbGl0eS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxpRUFBaUU7QUFDakUsT0FBTyxFQUFFLFVBQVUsRUFBMEIsTUFBTSxpQkFBaUIsQ0FBQztBQUNyRSxPQUFPLEVBQUUsa0JBQWtCLEVBQWtDLE1BQU0seUJBQXlCLENBQUM7QUFDN0YsT0FBTyxFQUFFLCtCQUErQixFQUErQyxNQUFNLHNDQUFzQyxDQUFDIn0=

package/dist/src/npc/behavior-tree/behaviors/conditions/BlackboardValueCondition.d.ts

@@ -0,0 +1,40 @@
+import { BehaviorStatus } from '../../BehaviorNode.js';
+import { ConditionEvaluator, type ConditionEvaluatorOptions } from '../ConditionEvaluator.js';
+import type { Blackboard } from '../../blackboard/Blackboard.js';
+export type ComparisonOperator = 'equals' | 'notEquals' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'exists' | 'notExists';
+export interface BlackboardValueConditionOptions extends ConditionEvaluatorOptions {
+    /** The blackboard key to check */
+    key: string;
+    /** The value to compare against (not needed for 'exists' and 'notExists' operators) */
+    value?: any;
+    /** The comparison operator to use */
+    operator?: ComparisonOperator;
+    /** Type of the value for better comparison (optional) */
+    valueType?: 'string' | 'number' | 'boolean' | 'object';
+}
+/**
+ * A flexible condition evaluator that can check any blackboard value using various comparison operators.
+ * This provides a generic way to check blackboard state without creating specialized condition classes.
+ *
+ * Examples:
+ * - Check if a boolean flag is true: { key: 'IsPlayerVisible', value: true, operator: 'equals' }
+ * - Check if a number is above threshold: { key: 'PlayerDistance', value: 10, operator: 'greaterThan' }
+ * - Check if a value exists: { key: 'LastKnownPosition', operator: 'exists' }
+ * - Check if a string matches: { key: 'CurrentState', value: 'Patrol', operator: 'equals' }
+ */
+export declare class BlackboardValueCondition extends ConditionEvaluator {
+    private key;
+    private value;
+    private operator;
+    private valueType?;
+    constructor(options: BlackboardValueConditionOptions);
+    protected onEvaluate(blackboard: Blackboard): Promise<BehaviorStatus>;
+    private compareValues;
+    getDebugInfo(): {
+        name: string;
+        description: string;
+        key: string;
+        value: any;
+        operator: string;
+    };
+}

package/dist/src/npc/behavior-tree/behaviors/conditions/BlackboardValueCondition.js

@@ -0,0 +1,133 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { EngineClass } from '../../../../systems/ClassRegistry.js';
+import { BehaviorStatus } from '../../BehaviorNode.js';
+import { ConditionEvaluator } from '../ConditionEvaluator.js';
+/**
+ * A flexible condition evaluator that can check any blackboard value using various comparison operators.
+ * This provides a generic way to check blackboard state without creating specialized condition classes.
+ *
+ * Examples:
+ * - Check if a boolean flag is true: { key: 'IsPlayerVisible', value: true, operator: 'equals' }
+ * - Check if a number is above threshold: { key: 'PlayerDistance', value: 10, operator: 'greaterThan' }
+ * - Check if a value exists: { key: 'LastKnownPosition', operator: 'exists' }
+ * - Check if a string matches: { key: 'CurrentState', value: 'Patrol', operator: 'equals' }
+ */
+let BlackboardValueCondition = class BlackboardValueCondition extends ConditionEvaluator {
+    constructor(options) {
+        super({
+            name: `BlackboardValue[${options.key}]`,
+            ...options
+        });
+        Object.defineProperty(this, "key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "operator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "valueType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.key = options.key;
+        this.value = options.value;
+        this.operator = options.operator ?? 'equals';
+        this.valueType = options.valueType;
+        // Validate that value is provided for operators that need it
+        if (this.operator !== 'exists' && this.operator !== 'notExists' && options.value === undefined) {
+            throw new Error(`BlackboardValueCondition: value is required for operator '${this.operator}'`);
+        }
+    }
+    async onEvaluate(blackboard) {
+        const actualValue = blackboard.getValue(this.key);
+        switch (this.operator) {
+            case 'exists':
+                return actualValue !== undefined ? BehaviorStatus.Success : BehaviorStatus.Failure;
+            case 'notExists':
+                return actualValue === undefined ? BehaviorStatus.Success : BehaviorStatus.Failure;
+            case 'equals':
+                return this.compareValues(actualValue, this.value, '===') ? BehaviorStatus.Success : BehaviorStatus.Failure;
+            case 'notEquals':
+                return this.compareValues(actualValue, this.value, '!==') ? BehaviorStatus.Success : BehaviorStatus.Failure;
+            case 'greaterThan':
+                return this.compareValues(actualValue, this.value, '>') ? BehaviorStatus.Success : BehaviorStatus.Failure;
+            case 'greaterThanOrEqual':
+                return this.compareValues(actualValue, this.value, '>=') ? BehaviorStatus.Success : BehaviorStatus.Failure;
+            case 'lessThan':
+                return this.compareValues(actualValue, this.value, '<') ? BehaviorStatus.Success : BehaviorStatus.Failure;
+            case 'lessThanOrEqual':
+                return this.compareValues(actualValue, this.value, '<=') ? BehaviorStatus.Success : BehaviorStatus.Failure;
+            default:
+                console.warn(`BlackboardValueCondition: Unknown operator '${this.operator}'`);
+                return BehaviorStatus.Failure;
+        }
+    }
+    compareValues(actualValue, expectedValue, operator) {
+        // Handle undefined/null values
+        if (actualValue === undefined || actualValue === null) {
+            if (operator === '===' || operator === '!==') {
+                return operator === '===' ? actualValue === expectedValue : actualValue !== expectedValue;
+            }
+            return false; // Can't do numeric comparisons with undefined/null
+        }
+        // Handle numeric comparisons
+        if (operator === '>' || operator === '>=' || operator === '<' || operator === '<=') {
+            const actualNum = Number(actualValue);
+            const expectedNum = Number(expectedValue);
+            if (isNaN(actualNum) || isNaN(expectedNum)) {
+                console.warn(`BlackboardValueCondition: Cannot perform numeric comparison on non-numeric values: ${actualValue} ${operator} ${expectedValue}`);
+                return false;
+            }
+            switch (operator) {
+                case '>': return actualNum > expectedNum;
+                case '>=': return actualNum >= expectedNum;
+                case '<': return actualNum < expectedNum;
+                case '<=': return actualNum <= expectedNum;
+                default: return false;
+            }
+        }
+        // Handle equality comparisons
+        if (operator === '===') {
+            return actualValue === expectedValue;
+        }
+        if (operator === '!==') {
+            return actualValue !== expectedValue;
+        }
+        return false;
+    }
+    getDebugInfo() {
+        return {
+            ...super.getDebugInfo(),
+            key: this.key,
+            value: this.value,
+            operator: this.operator
+        };
+    }
+};
+BlackboardValueCondition = __decorate([
+    EngineClass('BlackboardValueCondition'),
+    __metadata("design:paramtypes", [Object])
+], BlackboardValueCondition);
+export { BlackboardValueCondition };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/npc/behavior-tree/behaviors/conditions/CanSeeTargetCondition.d.ts

@@ -0,0 +1,29 @@
+import { BehaviorStatus } from '../../BehaviorNode.js';
+import { ConditionEvaluator, type ConditionEvaluatorOptions } from '../ConditionEvaluator.js';
+import type { Blackboard } from '../../blackboard/Blackboard.js';
+export interface CanSeeTargetConditionOptions extends ConditionEvaluatorOptions {
+    /** Blackboard key containing the target actor to check visibility of */
+    targetActorKey?: string;
+    /** Blackboard key containing the target position to check visibility of */
+    targetPositionKey?: string;
+    /** Maximum distance for line-of-sight check */
+    maxDistance?: number;
+    /** Height offset for the eye position of the owner */
+    eyeHeightOffset?: number;
+    /** Height offset for the target position */
+    targetHeightOffset?: number;
+}
+/**
+ * Condition evaluator that checks if the owner can see a target.
+ * Uses raycasting to determine line-of-sight.
+ */
+export declare class CanSeeTargetCondition extends ConditionEvaluator {
+    private targetActorKey?;
+    private targetPositionKey?;
+    private maxDistance;
+    private eyeHeightOffset;
+    private targetHeightOffset;
+    constructor(options?: CanSeeTargetConditionOptions);
+    protected onEvaluate(blackboard: Blackboard): Promise<BehaviorStatus>;
+    private getTargetPosition;
+}