@directivegames/genesys.js 3.1.24

package/dist/src/components/gameplay/PickupComponent.js

@@ -0,0 +1,429 @@
+/**
+ * PickupComponent provides pickup functionality for actors with trigger physics components.
+ *
+ * This component automatically finds trigger-enabled SceneComponents on its actor and
+ * sets up collision detection for pickup interactions. It includes support for sound
+ * effects when collected and provides extensible pickup behavior through delegates
+ * and virtual methods.
+ *
+ * Key Features:
+ * - Automatic trigger component detection (requires isTrigger=true physics state)
+ * - Sound effect support with configurable volume and distance
+ * - Delegate-based event system (onPickup) for external handling
+ * - Extensible pickup logic through canPickup and onPickupInternal overrides
+ * - Built-in actor destruction after pickup
+ *
+ * Included Classes:
+ * - PickupComponent: Base pickup functionality with sound support
+ * - HealthPickupComponent: Specialized pickup that heals CharacterStatsComponent
+ * - PickupSpawnerComponent: Automated spawning system with configurable intervals
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Attach to an actor that has a SceneComponent with physics enabled
+ * - Ensure the physics component has isTrigger: true and generateCollisionEvents: true
+ * - Override canPickup and onPickupInternal methods for custom pickup behavior
+ * - Use HealthPickupComponent for health restoration functionality
+ * - Use PickupSpawnerComponent for automatic pickup respawning
+ */
+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);
+};
+var PickupComponent_1, HealthPickupComponent_1, PickupSpawnerComponent_1;
+import * as THREE from 'three';
+import * as ENGINE from '../../index.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { Delegate } from '../../utils/Delegate.js';
+import { PrimitiveComponent } from '../PrimitiveComponent.js';
+import { SceneComponent } from '../SceneComponent.js';
+let PickupComponent = PickupComponent_1 = class PickupComponent extends SceneComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...SceneComponent.DEFAULT_OPTIONS,
+            sound: {
+                volume: 0.5,
+                maxDistance: 10
+            }
+        };
+    }
+    constructor(options = {}) {
+        // Merge sound options from DEFAULT_OPTIONS with any passed options
+        const mergedOptions = {
+            ...options,
+            sound: {
+                ...PickupComponent_1.DEFAULT_OPTIONS.sound,
+                ...options.sound
+            }
+        };
+        super(mergedOptions);
+        Object.defineProperty(this, "pickupSoundUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "triggerComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** Delegate called when this pickup is collected */
+        Object.defineProperty(this, "onPickup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        // Store pickup sound URL if configured
+        if (mergedOptions.sound?.pickupSoundUrl) {
+            this.pickupSoundUrl = mergedOptions.sound.pickupSoundUrl;
+        }
+    }
+    beginPlay() {
+        super.beginPlay();
+        // do it in the next tick to allow physics to be initialized
+        this.getWorld()?.runInNextTick(() => {
+            this.findTriggerComponent();
+        });
+        // special handling for GLTFMeshComponents which can take some time to load
+        const gltfMeshComponents = this.getActor()?.getComponents(ENGINE.GLTFMeshComponent) ?? [];
+        for (const gltfMeshComponent of gltfMeshComponents) {
+            gltfMeshComponent.onMeshLoaded.add((gltfMeshComponent, mesh) => {
+                this.findTriggerComponent();
+            });
+        }
+    }
+    findTriggerComponent() {
+        if (this.triggerComponent) {
+            return;
+        }
+        const actor = this.getActor();
+        if (!actor) {
+            console.warn('[PickupComponent] No actor found');
+            return;
+        }
+        const allPrimitiveComponents = actor.getComponents(PrimitiveComponent);
+        for (const primitiveComponent of allPrimitiveComponents) {
+            if (!primitiveComponent.getPhysicsOptions()?.generateCollisionEvents) {
+                continue;
+            }
+            const physicsState = this.getPhysicsEngine()?.getComponentState(primitiveComponent);
+            if (!physicsState) {
+                continue;
+            }
+            if (physicsState.isTrigger) {
+                this.triggerComponent = primitiveComponent;
+                break;
+            }
+        }
+        if (!this.triggerComponent) {
+            return;
+        }
+        // Set up overlap detection on the mesh component
+        this.triggerComponent.onOverlapWith.add((thisComponent, otherComponent, collisionEvent) => {
+            const otherActor = otherComponent.getActor();
+            // Check if the pickup can be collected by this actor
+            if (otherActor && this.canPickup(otherActor)) {
+                this.handlePickup(otherActor);
+            }
+        });
+        console.log('[PickupComponent] Successfully initialized with trigger component');
+    }
+    /**
+     * Determines if the pickup can be collected by the given actor
+     * Override this method in subclasses to implement custom pickup logic
+     * @param actor The actor attempting to pick up this item
+     * @returns True if the actor can pick up this item
+     */
+    canPickup(actor) {
+        // Default implementation: only Pawns can pick up items
+        return actor instanceof ENGINE.Pawn;
+    }
+    /**
+     * Internal method that handles the pickup process
+     * @param collector The actor that collected this pickup
+     */
+    handlePickup(collector) {
+        const pickupActor = this.getActor();
+        if (!pickupActor)
+            return;
+        // Invoke the delegate first (before destroying the actor)
+        this.onPickup.invoke(pickupActor, collector);
+        // Then call the overridable method
+        this.onPickupInternal(collector);
+    }
+    /**
+     * Called when the pickup is collected
+     * Override this method in subclasses to implement custom pickup behavior
+     * @param collector The actor that collected this pickup
+     */
+    onPickupInternal(collector) {
+        console.log('[PickupComponent] Pickup collected!');
+        if (this.pickupSoundUrl) {
+            const world = this.getWorld();
+            if (world?.globalAudioManager) {
+                const soundOptions = this.options.sound;
+                world.globalAudioManager.playGlobalSound(this.pickupSoundUrl, {
+                    volume: soundOptions?.volume ?? 0.7
+                });
+            }
+        }
+        else {
+            console.log('[PickupComponent] No pickup sound configured');
+        }
+        // Remove the pickup actor from the world
+        const actor = this.getActor();
+        if (actor) {
+            actor.destroy();
+        }
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_Pickup';
+    }
+};
+Object.defineProperty(PickupComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        ...SceneComponent.EDITOR_CLASS_META,
+    }
+});
+PickupComponent = PickupComponent_1 = __decorate([
+    EngineClass('PickupComponent'),
+    __metadata("design:paramtypes", [Object])
+], PickupComponent);
+export { PickupComponent };
+let HealthPickupComponent = HealthPickupComponent_1 = class HealthPickupComponent extends PickupComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...PickupComponent.DEFAULT_OPTIONS,
+            healAmount: 25,
+            sound: {
+                pickupSoundUrl: '@engine/assets/sounds/pickup.mp3',
+                volume: 0.7,
+                maxDistance: 12
+            }
+        };
+    }
+    constructor(options = {}) {
+        super(options);
+        Object.defineProperty(this, "healAmount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.healAmount = options.healAmount ?? HealthPickupComponent_1.DEFAULT_OPTIONS.healAmount;
+    }
+    /**
+     * Override to ensure only Pawns with CharacterStatsComponent can pick up health
+     */
+    canPickup(actor) {
+        // First check if it's a Pawn (base class requirement)
+        if (!super.canPickup(actor)) {
+            return false;
+        }
+        // Then check if it has a CharacterStatsComponent
+        const pawn = actor;
+        const statsComponent = pawn.getComponent(ENGINE.CharacterStatsComponent);
+        return statsComponent !== null;
+    }
+    /**
+     * Override to heal the player when picked up
+     */
+    onPickupInternal(collector) {
+        const player = collector;
+        const statsComponent = player.getComponent(ENGINE.CharacterStatsComponent);
+        if (statsComponent) {
+            const currentHealth = statsComponent.getCurrentHealth();
+            const maxHealth = statsComponent.getMaxHealth();
+            // Heal the player
+            const actualHealed = statsComponent.heal(this.healAmount);
+            console.log(`[HealthPickupComponent] Healed player: ${currentHealth}/${maxHealth} -> ${statsComponent.getCurrentHealth()}/${maxHealth} (healed ${actualHealed} HP)`);
+        }
+        // Call the base pickup behavior (destroy)
+        super.onPickupInternal(collector);
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_HealthPickup';
+    }
+};
+HealthPickupComponent = HealthPickupComponent_1 = __decorate([
+    EngineClass('HealthPickupComponent'),
+    __metadata("design:paramtypes", [Object])
+], HealthPickupComponent);
+export { HealthPickupComponent };
+let PickupSpawnerComponent = PickupSpawnerComponent_1 = class PickupSpawnerComponent extends SceneComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...SceneComponent.DEFAULT_OPTIONS,
+            prefabPath: '@engine/assets/prefabs/actors/demo_health_pickup.prefab.json',
+            spawnInterval: 5.0,
+            spawnOffset: new THREE.Vector3(0, 2, 0),
+            sound: undefined,
+        };
+    }
+    constructor(options = {}) {
+        const mergedOptions = {
+            ...PickupSpawnerComponent_1.DEFAULT_OPTIONS,
+            ...options,
+            sound: {
+                ...PickupSpawnerComponent_1.DEFAULT_OPTIONS.sound,
+                ...options.sound
+            }
+        };
+        super(mergedOptions);
+        Object.defineProperty(this, "currentPickup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "spawnTimerId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    beginPlay() {
+        super.beginPlay();
+        console.log('[PickupSpawnerComponent] Starting pickup spawner');
+        // Spawn the initial pickup
+        this.spawnPickup();
+    }
+    endPlay() {
+        super.endPlay();
+        // Clean up timer
+        if (this.spawnTimerId !== null) {
+            const world = this.getWorld();
+            if (world) {
+                world.timerSystem.clearTimer(this.spawnTimerId);
+                this.spawnTimerId = null;
+            }
+        }
+    }
+    async spawnPickup() {
+        const world = this.getWorld();
+        const actor = this.getActor();
+        if (!world || !actor) {
+            console.warn('[PickupSpawnerComponent] No world or actor found');
+            return;
+        }
+        const options = this.options;
+        if (!options.prefabPath) {
+            console.warn('[PickupSpawnerComponent] No prefab path specified');
+            return;
+        }
+        try {
+            // Calculate spawn position
+            const spawnerPosition = actor.rootComponent.getWorldPosition();
+            const spawnOffset = options.spawnOffset ?? new THREE.Vector3(0, 2, 0);
+            const spawnPosition = spawnerPosition.clone().add(spawnOffset);
+            // Spawn the pickup using WorldCommands
+            const pickupActors = await ENGINE.WorldCommands.placePrefabs({
+                world: world,
+                prefabs: [
+                    {
+                        path: options.prefabPath,
+                        transform: {
+                            position: spawnPosition,
+                            rotation: new THREE.Euler(0, 0, 0)
+                        }
+                    }
+                ]
+            });
+            if (pickupActors.length > 0) {
+                this.currentPickup = pickupActors[0];
+                // Find the pickup component and bind to its onPickup delegate
+                const pickupComponent = this.currentPickup.getComponent(PickupComponent);
+                if (pickupComponent) {
+                    pickupComponent.onPickup.add((pickupActor, collector) => {
+                        this.onPickupCollected(pickupActor, collector);
+                    });
+                }
+                // Play spawn sound if configured
+                if (options.sound?.spawnSoundUrl) {
+                    world.globalAudioManager?.playGlobalSound(options.sound.spawnSoundUrl, {
+                        volume: options.sound.volume ?? 0.5
+                    });
+                }
+                console.log('[PickupSpawnerComponent] Spawned pickup at:', spawnPosition);
+            }
+        }
+        catch (error) {
+            console.error('[PickupSpawnerComponent] Failed to spawn pickup:', error);
+        }
+    }
+    onPickupCollected(pickupActor, collector) {
+        console.log('[PickupSpawnerComponent] Pickup was collected');
+        this.currentPickup = null;
+        const options = this.options;
+        const spawnInterval = options.spawnInterval ?? 5.0;
+        // Only respawn if interval is non-negative
+        if (spawnInterval >= 0) {
+            const world = this.getWorld();
+            if (world) {
+                // Schedule the next spawn
+                this.spawnTimerId = world.timerSystem.setTimeout(() => {
+                    this.spawnTimerId = null;
+                    this.spawnPickup();
+                }, spawnInterval);
+                console.log(`[PickupSpawnerComponent] Next pickup will spawn in ${spawnInterval} seconds`);
+            }
+        }
+        else {
+            console.log('[PickupSpawnerComponent] Single-use spawner, will not respawn');
+        }
+    }
+    /**
+     * Manually trigger a pickup spawn (if no pickup is currently active)
+     */
+    manualSpawn() {
+        if (!this.currentPickup) {
+            this.spawnPickup();
+        }
+        else {
+            console.log('[PickupSpawnerComponent] Cannot spawn, pickup already exists');
+        }
+    }
+    /**
+     * Get the currently spawned pickup actor
+     */
+    getCurrentPickup() {
+        return this.currentPickup;
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_Pickup';
+    }
+};
+Object.defineProperty(PickupSpawnerComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        ...SceneComponent.EDITOR_CLASS_META,
+    }
+});
+PickupSpawnerComponent = PickupSpawnerComponent_1 = __decorate([
+    EngineClass('PickupSpawnerComponent'),
+    __metadata("design:paramtypes", [Object])
+], PickupSpawnerComponent);
+export { PickupSpawnerComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PickupComponent.js","sourceRoot":"","sources":["../../../../src/components/gameplay/PickupComponent.ts"],"names":[],"mappings":"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"}

package/dist/src/components/gameplay/ProjectileWeaponComponent.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ProjectileWeaponComponent fires Projectile actors with configurable options.
+ *
+ * Built on top of BaseWeaponComponent, it gathers the firing position and
+ * direction from the owning component and instantiates a Projectile each time
+ * `doFire` is called. Target positions can be provided to force shots toward a
+ * point in world space. The projectile class is customizable allowing different
+ * projectile behaviors without modifying the component itself.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Set `projectileOptions` to control speed, collision settings and more.
+ * - Call `tryFireAtTarget` for one-off shots toward a specific position.
+ * - Override `getFirePositionAndDirection` if the spawn point should be offset
+ *   from the component's transform.
+ */
+import { Projectile } from '../../actors/Projectile.js';
+import { Delegate } from '../../utils/Delegate.js';
+import { BaseWeaponComponent } from './BaseWeaponComponent.js';
+import type { BaseWeaponOptions } from './BaseWeaponComponent.js';
+import type { IEquipment } from './Equipment.js';
+import type { ProjectileOptions } from '../../actors/Projectile.js';
+import type { OptionalSome } from '../../utils/Utils.js';
+import type * as THREE from 'three';
+export type WeaponProjectileOptions = OptionalSome<ProjectileOptions, 'position' | 'direction'>;
+export interface ProjectileWeaponOptions extends BaseWeaponOptions {
+    projectileOptions: WeaponProjectileOptions;
+    /**
+     * Optional class to use for the projectile.
+     * If not provided, the default Projectile class will be used.
+     */
+    projectileClass?: new (options: ProjectileOptions) => Projectile;
+    /**
+     * Optional offset from the weapon component's position for the projectile spawn.
+     */
+    projectileSpawnOffset?: THREE.Vector3;
+}
+export type ProjectileFiredDelegate = Delegate<[Projectile], void>;
+export type ProjectileWeaponDefaultOptions = BaseWeaponOptions & Partial<ProjectileWeaponOptions>;
+export declare class ProjectileWeaponComponent extends BaseWeaponComponent<ProjectileWeaponOptions> implements IEquipment {
+    static get DEFAULT_OPTIONS(): ProjectileWeaponDefaultOptions;
+    readonly onProjectileFired: ProjectileFiredDelegate;
+    constructor(options: ProjectileWeaponOptions);
+    protected doFire(): void;
+    protected getFirePositionAndDirection(): {
+        position: THREE.Vector3;
+        direction: THREE.Vector3;
+    };
+    getEditorClassIcon(): string | null;
+}

package/dist/src/components/gameplay/ProjectileWeaponComponent.js

@@ -0,0 +1,93 @@
+/**
+ * ProjectileWeaponComponent fires Projectile actors with configurable options.
+ *
+ * Built on top of BaseWeaponComponent, it gathers the firing position and
+ * direction from the owning component and instantiates a Projectile each time
+ * `doFire` is called. Target positions can be provided to force shots toward a
+ * point in world space. The projectile class is customizable allowing different
+ * projectile behaviors without modifying the component itself.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Set `projectileOptions` to control speed, collision settings and more.
+ * - Call `tryFireAtTarget` for one-off shots toward a specific position.
+ * - Override `getFirePositionAndDirection` if the spawn point should be offset
+ *   from the component's transform.
+ */
+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);
+};
+var ProjectileWeaponComponent_1;
+import { Projectile } from '../../actors/Projectile.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { Delegate } from '../../utils/Delegate.js';
+import { BaseWeaponComponent } from './BaseWeaponComponent.js';
+let ProjectileWeaponComponent = ProjectileWeaponComponent_1 = class ProjectileWeaponComponent extends BaseWeaponComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...BaseWeaponComponent.DEFAULT_OPTIONS,
+            projectileClass: Projectile,
+        };
+    }
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, "onProjectileFired", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+    }
+    doFire() {
+        // Guard against firing without ammo
+        if (!this.canFire()) {
+            return;
+        }
+        let { position, direction } = this.getFirePositionAndDirection();
+        // Apply target direction if available
+        const targetDirection = this.getTargetDirection();
+        if (targetDirection) {
+            direction = targetDirection;
+        }
+        const projectileClass = this.options.projectileClass ?? ProjectileWeaponComponent_1.DEFAULT_OPTIONS.projectileClass;
+        const projectile = new projectileClass({
+            ...this.options.projectileOptions,
+            // honor the provided position and direction if they exist
+            position: this.options.projectileOptions.position ?? position,
+            direction: this.options.projectileOptions.direction ?? direction,
+            // Pass the owner actor so the projectile won't hit its owner
+            owner: this.getActor() ?? undefined,
+        });
+        this.getWorld()?.addActors(projectile);
+        this.onProjectileFired.invoke(projectile);
+        // Handle weapon effects and ammo
+        this.consumeAmmo();
+        this.playFireSound();
+        this.applyRecoilEffects();
+    }
+    getFirePositionAndDirection() {
+        const { position, direction } = super.getFirePositionAndDirection();
+        // Apply projectile-specific spawn offset if provided
+        if (this.options.projectileSpawnOffset) {
+            position.add(this.options.projectileSpawnOffset.clone().applyQuaternion(this.getWorldQuaternion()));
+        }
+        return { position, direction };
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_ProjectileWeapon';
+    }
+};
+ProjectileWeaponComponent = ProjectileWeaponComponent_1 = __decorate([
+    EngineClass('ProjectileWeaponComponent'),
+    __metadata("design:paramtypes", [Object])
+], ProjectileWeaponComponent);
+export { ProjectileWeaponComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/components/gameplay/ShotgunComponent.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+import { ProjectileWeaponComponent } from './ProjectileWeaponComponent.js';
+import type { ProjectileWeaponOptions } from './ProjectileWeaponComponent.js';
+export declare class ShotgunComponent extends ProjectileWeaponComponent {
+    private originalRotation;
+    private reloadRotation;
+    private isRotating;
+    static readonly SHOTGUN_CONFIG: ProjectileWeaponOptions;
+    constructor();
+    protected get gunMesh(): THREE.Object3D | null;
+    protected startReload(): void;
+    private animateRotationTo;
+    private easeInOutCubic;
+    beginFire(): boolean;
+    protected doFire(): void;
+    private createMuzzleFlashEffect;
+    getEditorClassIcon(): string | null;
+}