@directivegames/genesys.js 3.1.24

package/dist/src/npc/behavior-tree/behaviors/actions/aerial/AerialWanderAction.d.ts

@@ -0,0 +1,50 @@
+import * as THREE from 'three';
+import { BehaviorStatus } from '../../../BehaviorNode.js';
+import { BehaviorAction, type BehaviorActionOptions } from '../../BehaviorAction.js';
+import type { Blackboard } from '../../../blackboard/Blackboard.js';
+export interface AerialWanderActionOptions extends BehaviorActionOptions {
+    /** Radius around spawn point to wander within */
+    wanderRadius?: number;
+    /** Height at which to wander */
+    wanderHeight?: number;
+    /** Height variation for wandering */
+    heightVariation?: number;
+    /** Time to spend at each wander point */
+    waitTime?: number;
+    /** Speed multiplier for wandering movement */
+    speedMultiplier?: number;
+}
+/**
+ * Action that makes an aerial NPC wander randomly in the sky when it has no
+ * information about the player location. Creates random patrol points within
+ * a specified radius and flies between them.
+ */
+export declare class AerialWanderAction extends BehaviorAction {
+    private wanderRadius;
+    private wanderHeight;
+    private heightVariation;
+    private waitTime;
+    private speedMultiplier;
+    private movementComponent;
+    private spawnPosition;
+    private currentWanderTarget;
+    private waitStartTime;
+    private isWaiting;
+    constructor(options?: AerialWanderActionOptions);
+    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;
+    /**
+     * Generates a new random wander target within the wander radius
+     */
+    private generateNewWanderTarget;
+    /**
+     * Gets the current wander target position
+     */
+    getCurrentWanderTarget(): THREE.Vector3 | null;
+    /**
+     * Checks if the drone is currently waiting at a wander point
+     */
+    isCurrentlyWaiting(): boolean;
+}

package/dist/src/npc/behavior-tree/behaviors/actions/aerial/AerialWanderAction.js

@@ -0,0 +1,189 @@
+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 { EngineClass } from '../../../../../systems/ClassRegistry.js';
+import { BehaviorStatus } from '../../../BehaviorNode.js';
+import { BehaviorAction } from '../../BehaviorAction.js';
+/**
+ * Action that makes an aerial NPC wander randomly in the sky when it has no
+ * information about the player location. Creates random patrol points within
+ * a specified radius and flies between them.
+ */
+let AerialWanderAction = class AerialWanderAction extends BehaviorAction {
+    constructor(options = {}) {
+        super({
+            name: 'AerialWander',
+            ...options
+        });
+        Object.defineProperty(this, "wanderRadius", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "wanderHeight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "heightVariation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "waitTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "speedMultiplier", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "movementComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "spawnPosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "currentWanderTarget", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "waitStartTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "isWaiting", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.wanderRadius = options.wanderRadius ?? 30.0;
+        this.wanderHeight = options.wanderHeight ?? 20.0;
+        this.heightVariation = options.heightVariation ?? 8.0;
+        this.waitTime = options.waitTime ?? 3.0;
+        this.speedMultiplier = options.speedMultiplier ?? 0.7;
+    }
+    onInitialize(blackboard) {
+        const owner = this.getOwner(blackboard);
+        if (!owner) {
+            return;
+        }
+        this.movementComponent = owner.getComponent(AerialMovementComponent);
+        if (!this.movementComponent) {
+            console.warn('AerialWanderAction: No AerialMovementComponent found on actor');
+            return;
+        }
+        // Store spawn position for wandering around
+        if (!this.spawnPosition) {
+            this.spawnPosition = new THREE.Vector3();
+            owner.rootComponent.getWorldPosition(this.spawnPosition);
+        }
+    }
+    onEnter(blackboard) {
+        // Generate new wander target (or continue with existing one if still valid)
+        if (!this.currentWanderTarget || this.isWaiting) {
+            this.generateNewWanderTarget();
+        }
+        this.isWaiting = false;
+    }
+    async onUpdate(blackboard, deltaTime) {
+        const owner = this.getOwner(blackboard);
+        if (!owner || !this.movementComponent || !this.spawnPosition) {
+            return BehaviorStatus.Failure;
+        }
+        const currentTime = Date.now() / 1000;
+        const ownerPosition = new THREE.Vector3();
+        owner.rootComponent.getWorldPosition(ownerPosition);
+        if (this.isWaiting) {
+            // Wait at current position
+            const waitElapsed = currentTime - this.waitStartTime;
+            if (waitElapsed >= this.waitTime) {
+                // Done waiting, complete the action to allow behavior tree re-evaluation
+                return BehaviorStatus.Success;
+            }
+            return BehaviorStatus.Running;
+        }
+        if (this.currentWanderTarget) {
+            // Move toward current wander target
+            this.movementComponent.setTargetPosition(this.currentWanderTarget);
+            // Check if we've reached the target
+            const distance = ownerPosition.distanceTo(this.currentWanderTarget);
+            if (distance <= 3.0) { // Close enough to target
+                // Start waiting
+                this.movementComponent.clearTarget();
+                this.isWaiting = true;
+                this.waitStartTime = currentTime;
+            }
+        }
+        else {
+            // No target, generate one
+            this.generateNewWanderTarget();
+        }
+        return BehaviorStatus.Running;
+    }
+    onExit(blackboard, status) {
+        // Clear movement target
+        if (this.movementComponent) {
+            this.movementComponent.clearTarget();
+        }
+    }
+    /**
+     * Generates a new random wander target within the wander radius
+     */
+    generateNewWanderTarget() {
+        if (!this.spawnPosition) {
+            return;
+        }
+        // Generate random point within wander radius
+        const angle = Math.random() * Math.PI * 2;
+        const distance = Math.random() * this.wanderRadius;
+        const x = this.spawnPosition.x + Math.cos(angle) * distance;
+        const z = this.spawnPosition.z + Math.sin(angle) * distance;
+        const y = this.wanderHeight + (Math.random() - 0.5) * this.heightVariation;
+        this.currentWanderTarget = new THREE.Vector3(x, y, z);
+    }
+    /**
+     * Gets the current wander target position
+     */
+    getCurrentWanderTarget() {
+        return this.currentWanderTarget?.clone() ?? null;
+    }
+    /**
+     * Checks if the drone is currently waiting at a wander point
+     */
+    isCurrentlyWaiting() {
+        return this.isWaiting;
+    }
+};
+AerialWanderAction = __decorate([
+    EngineClass('AerialWanderAction'),
+    __metadata("design:paramtypes", [Object])
+], AerialWanderAction);
+export { AerialWanderAction };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,4 @@
+export { AerialMoveToTargetAction, type AerialMoveToTargetActionOptions } from './AerialMoveToTargetAction.js';
+export { AerialSearchAction, type AerialSearchActionOptions } from './AerialSearchAction.js';
+export { AerialTrackTargetAction, type AerialTrackTargetActionOptions } from './AerialTrackTargetAction.js';
+export { AerialWanderAction, type AerialWanderActionOptions } from './AerialWanderAction.js';

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

@@ -0,0 +1,6 @@
+// Aerial movement actions (3D flying actions)
+export { AerialMoveToTargetAction } from './AerialMoveToTargetAction.js';
+export { AerialSearchAction } from './AerialSearchAction.js';
+export { AerialTrackTargetAction } from './AerialTrackTargetAction.js';
+export { AerialWanderAction } from './AerialWanderAction.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbnBjL2JlaGF2aW9yLXRyZWUvYmVoYXZpb3JzL2FjdGlvbnMvYWVyaWFsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDhDQUE4QztBQUM5QyxPQUFPLEVBQUUsd0JBQXdCLEVBQXdDLE1BQU0sK0JBQStCLENBQUM7QUFDL0csT0FBTyxFQUFFLGtCQUFrQixFQUFrQyxNQUFNLHlCQUF5QixDQUFDO0FBQzdGLE9BQU8sRUFBRSx1QkFBdUIsRUFBdUMsTUFBTSw4QkFBOEIsQ0FBQztBQUM1RyxPQUFPLEVBQUUsa0JBQWtCLEVBQWtDLE1BQU0seUJBQXlCLENBQUMifQ==

package/dist/src/npc/behavior-tree/behaviors/actions/combat/MeleeAttackAction.d.ts

@@ -0,0 +1,37 @@
+import { BehaviorStatus } from '../../../BehaviorNode.js';
+import { BehaviorAction, type BehaviorActionOptions } from '../../BehaviorAction.js';
+import type { Blackboard } from '../../../blackboard/Blackboard.js';
+export interface MeleeAttackActionOptions extends BehaviorActionOptions {
+    /** Blackboard key containing the target to attack */
+    targetActorKey?: string;
+    /** Maximum range for melee attack */
+    attackRange?: number;
+    /** Damage to deal */
+    damage?: number;
+    /** Time between attacks in seconds */
+    attackCooldown?: number;
+    /** Duration of the attack animation/effect */
+    attackDuration?: number;
+}
+/**
+ * Action that performs a melee attack on a target.
+ * The NPC will attack the target if it's within range.
+ */
+export declare class MeleeAttackAction extends BehaviorAction {
+    private targetActorKey?;
+    private attackRange;
+    private damage;
+    private attackCooldown;
+    private attackDuration;
+    private movementComponent;
+    private lastAttackTime;
+    private isAttacking;
+    private attackStartTime;
+    constructor(options?: MeleeAttackActionOptions);
+    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 getTarget;
+    private startAttack;
+}

package/dist/src/npc/behavior-tree/behaviors/actions/combat/MeleeAttackAction.js

@@ -0,0 +1,172 @@
+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 { CharacterStatsComponent } from '../../../../../components/CharacterStatsComponent.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 performs a melee attack on a target.
+ * The NPC will attack the target if it's within range.
+ */
+let MeleeAttackAction = class MeleeAttackAction extends BehaviorAction {
+    constructor(options = {}) {
+        super({
+            name: 'MeleeAttack',
+            ...options
+        });
+        Object.defineProperty(this, "targetActorKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "attackRange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "damage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "attackCooldown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "attackDuration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "movementComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "lastAttackTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "isAttacking", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "attackStartTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.targetActorKey = options.targetActorKey ?? 'PlayerActor';
+        this.attackRange = options.attackRange ?? 3.0;
+        this.damage = options.damage ?? 10;
+        this.attackCooldown = options.attackCooldown ?? 2.0;
+        this.attackDuration = options.attackDuration ?? 0.5;
+    }
+    onInitialize(blackboard) {
+        const owner = this.getOwner(blackboard);
+        if (!owner) {
+            return;
+        }
+        this.movementComponent = owner.getComponent(NpcMovementComponent);
+        if (!this.movementComponent) {
+            console.warn('MeleeAttackAction: No NpcMovementComponent found on actor');
+        }
+    }
+    onEnter(blackboard) {
+        this.isAttacking = false;
+    }
+    async onUpdate(blackboard, deltaTime) {
+        const owner = this.getOwner(blackboard);
+        if (!owner) {
+            return BehaviorStatus.Failure;
+        }
+        // Get target
+        const target = this.getTarget(blackboard);
+        if (!target) {
+            return BehaviorStatus.Failure;
+        }
+        // Get positions
+        const ownerPosition = new THREE.Vector3();
+        const targetPosition = new THREE.Vector3();
+        owner.rootComponent.getWorldPosition(ownerPosition);
+        target.rootComponent.getWorldPosition(targetPosition);
+        // Calculate distance
+        const distance = ownerPosition.distanceTo(targetPosition);
+        // Check if target is in range
+        if (distance > this.attackRange) {
+            return BehaviorStatus.Failure;
+        }
+        const currentTime = Date.now() / 1000;
+        // Check if we're currently attacking
+        if (this.isAttacking) {
+            const attackElapsed = currentTime - this.attackStartTime;
+            if (attackElapsed >= this.attackDuration) {
+                // Attack finished
+                this.isAttacking = false;
+                return BehaviorStatus.Success;
+            }
+            return BehaviorStatus.Running;
+        }
+        // Check cooldown
+        if (currentTime - this.lastAttackTime < this.attackCooldown) {
+            return BehaviorStatus.Running;
+        }
+        // Start attack
+        this.startAttack(owner, target);
+        this.lastAttackTime = currentTime;
+        this.attackStartTime = currentTime;
+        this.isAttacking = true;
+        return BehaviorStatus.Running;
+    }
+    onExit(blackboard, status) {
+        this.isAttacking = false;
+    }
+    getTarget(blackboard) {
+        if (this.targetActorKey) {
+            const actor = blackboard.getValue(this.targetActorKey);
+            if (actor) {
+                return actor;
+            }
+        }
+        return null;
+    }
+    startAttack(owner, target) {
+        // Stop movement during attack
+        if (this.movementComponent) {
+            this.movementComponent.stop();
+        }
+        // Deal damage to target
+        const targetStats = target.getComponent(CharacterStatsComponent);
+        if (targetStats) {
+            targetStats.takeDamage(this.damage);
+        }
+        // TODO: Add attack effects, sounds, etc.
+    }
+};
+MeleeAttackAction = __decorate([
+    EngineClass('MeleeAttackAction'),
+    __metadata("design:paramtypes", [Object])
+], MeleeAttackAction);
+export { MeleeAttackAction };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/npc/behavior-tree/behaviors/actions/combat/ShootAction.d.ts

@@ -0,0 +1,35 @@
+import { BehaviorStatus } from '../../../BehaviorNode.js';
+import { BehaviorAction, type BehaviorActionOptions } from '../../BehaviorAction.js';
+import type { Blackboard } from '../../../blackboard/Blackboard.js';
+export interface ShootActionOptions extends BehaviorActionOptions {
+    /** Blackboard key containing the target to shoot */
+    targetActorKey?: string;
+    /** Maximum range for shooting */
+    shootRange?: number;
+    /** Time between shots in seconds */
+    shootCooldown?: number;
+    /** Duration to aim before shooting */
+    aimDuration?: number;
+}
+/**
+ * Action that makes the NPC shoot at a target.
+ * The NPC will aim and then shoot if the target is within range and line of sight.
+ */
+export declare class ShootAction extends BehaviorAction {
+    private targetActorKey?;
+    private shootRange;
+    private shootCooldown;
+    private aimDuration;
+    private projectileWeapon;
+    private lastShootTime;
+    private isAiming;
+    private aimStartTime;
+    constructor(options?: ShootActionOptions);
+    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 getTarget;
+    private startAiming;
+    private performShoot;
+}