@directivegames/genesys.js 3.1.24

package/dist/src/actors/GlobalParticleManager.js

@@ -0,0 +1,365 @@
+/**
+ * GlobalParticleManager provides global VFX system management functionality.
+ *
+ * Manages wawa-vfx-vanilla VFX particles and emitters for advanced VFX effects.
+ * It serves as a container for fire-and-forget VFX spawning with automatic lifetime management.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Use spawnVFX() or spawnVFXFromPath() to create fire-and-forget VFX effects
+ * - Use for one-off particle effects like explosions, sparks, or impact effects
+ * - Access through world.getParticleManager() or GlobalParticleManager.getInstance()
+ * - VFX are automatically managed and removed when their lifetime expires
+ *
+ * Legacy ParticleEmitterComponent support:
+ * - attachParticleEmitter() is deprecated, use spawnVFX() instead
+ * - Old particle system will be removed in future versions
+ */
+import * as THREE from 'three';
+import * as WawaVFX from 'wawa-vfx-vanilla';
+import { AssetPath } from '../storage/storageProvider.js';
+import { resourceManager } from '../utils/ResourceManager.js';
+import { VFXDefinition } from '../vfx/types.js';
+import { Actor } from './Actor.js';
+// We don't need to register the class, because it should not be instantiated, and it's
+// always transient. We could also drop the base class, but since it has a child component,
+// this solution is easier.
+// @EngineClass('GlobalParticleManager')
+export class GlobalParticleManager extends Actor {
+    constructor(options = {}) {
+        super({
+            ...options,
+            position: new THREE.Vector3(0, 0, 0)
+        });
+        Object.defineProperty(this, "attachedParticles", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "attachedVFX", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "vfxParticlesRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    doEndPlay() {
+        this.cleanupAllParticles();
+        this.cleanupAllVFX();
+        this.cleanupVFXParticles();
+        super.doEndPlay();
+    }
+    tickPrePhysics(deltaTime) {
+        super.tickPrePhysics(deltaTime);
+        this.updateParticleLifecycles(deltaTime);
+        this.updateVFXLifecycles(deltaTime);
+        this.updateVFXParticles();
+    }
+    /**
+     * Attach a particle emitter component in a fire-and-forget fashion
+     * @param particleComponent The particle emitter component to attach
+     * @param options Configuration for the attachment
+     * @returns Unique identifier for this particle instance
+     * @deprecated Use spawnVFX() or spawnVFXFromPath() instead
+     */
+    attachParticleEmitter(particleComponent, options = {}) {
+        // Set position, rotation, and scale if provided
+        if (options.position) {
+            particleComponent.position.copy(options.position);
+        }
+        if (options.rotation) {
+            particleComponent.rotation.copy(options.rotation);
+        }
+        if (options.scale) {
+            particleComponent.scale.copy(options.scale);
+        }
+        // Attach the component to this actor's root
+        this.rootComponent.add(particleComponent);
+        const totalLifetime = options.lifetime ?? particleComponent.options.particleLifetime;
+        // Track the particle
+        const particleInfo = {
+            component: particleComponent,
+            attachTime: this.getWorld()?.getGameTime() ?? 0,
+            lifetime: totalLifetime,
+        };
+        this.attachedParticles.push(particleInfo);
+    }
+    /**
+     * Get information about all currently attached particles
+     * @returns Array of particle information
+     * @deprecated Use getAttachedVFX() instead
+     */
+    getAttachedParticles() {
+        return this.attachedParticles;
+    }
+    /**
+     * Manually cleanup all attached particles
+     * @deprecated Use cleanupAllVFX() instead
+     */
+    cleanupAllParticles() {
+        for (const particleInfo of this.attachedParticles) {
+            particleInfo.component.removeFromParent();
+        }
+        this.attachedParticles = [];
+    }
+    /**
+     * Update particle lifecycles and remove expired ones
+     * @deprecated - updates ParticleEmitterComponents which are not supported anymore
+     * @param deltaTime Time since last frame
+     */
+    updateParticleLifecycles(deltaTime) {
+        const world = this.getWorld();
+        if (!world)
+            return;
+        const currentTime = world.getGameTime();
+        const remainingParticles = [];
+        for (const particleInfo of this.attachedParticles) {
+            const elapsedTime = currentTime - particleInfo.attachTime;
+            if (elapsedTime < particleInfo.lifetime) {
+                remainingParticles.push(particleInfo);
+            }
+            else {
+                particleInfo.component.removeFromParent();
+            }
+        }
+        this.attachedParticles = remainingParticles;
+    }
+    /**
+     * Update VFX lifecycles and remove expired ones
+     * @param deltaTime Time since last frame
+     */
+    updateVFXLifecycles(deltaTime) {
+        const world = this.getWorld();
+        if (!world)
+            return;
+        const currentTime = world.getGameTime();
+        const remainingVFX = [];
+        for (const vfxInfo of this.attachedVFX) {
+            // Update the emitter with global time, not elapsed time
+            vfxInfo.emitter.update(currentTime, deltaTime);
+            const elapsedTime = currentTime - vfxInfo.attachTime;
+            if (elapsedTime < vfxInfo.lifetime) {
+                remainingVFX.push(vfxInfo);
+            }
+            else {
+                vfxInfo.emitter.removeFromParent();
+            }
+        }
+        this.attachedVFX = remainingVFX;
+    }
+    /**
+     * Update all registered VFXParticles systems
+     */
+    updateVFXParticles() {
+        const world = this.getWorld();
+        if (!world)
+            return;
+        const elapsedTime = world.getGameTime();
+        for (const vfxParticles of this.vfxParticlesRegistry.values()) {
+            vfxParticles.update(elapsedTime);
+        }
+    }
+    /**
+     * Manually cleanup all attached VFX
+     */
+    cleanupAllVFX() {
+        for (const vfxInfo of this.attachedVFX) {
+            vfxInfo.emitter.removeFromParent();
+        }
+        this.attachedVFX = [];
+    }
+    /**
+     * Cleanup all VFXParticles systems (dispose and remove from registry)
+     */
+    cleanupVFXParticles() {
+        const world = this.getWorld();
+        if (world) {
+            for (const [name, vfxParticles] of this.vfxParticlesRegistry) {
+                // Remove mesh from scene
+                world.scene.remove(vfxParticles.getMesh());
+                // Dispose VFXParticles
+                vfxParticles.dispose();
+            }
+        }
+        this.vfxParticlesRegistry.clear();
+    }
+    /**
+     * Get or create a VFXParticles instance for the given name
+     * @param name Unique identifier for the VFX particles system
+     * @param settings VFX particles settings
+     * @returns The VFXParticles instance
+     */
+    async getOrCreateVFXParticles(name, settings, alphaMap, geometry) {
+        let vfxParticles = this.vfxParticlesRegistry.get(name);
+        if (!vfxParticles) {
+            // Convert settings to wawa-vfx format
+            const internalSettings = {
+                nbParticles: settings.nbParticles ?? 1000,
+                intensity: settings.intensity ?? 1,
+                renderMode: settings.renderMode ?? 'billboard',
+                stretchScale: settings.stretchScale ?? 1.0,
+                fadeSize: settings.fadeSize ?? [0.1, 0.9],
+                fadeAlpha: settings.fadeAlpha ?? [0, 1.0],
+                gravity: settings.gravity ?? [0, 0, 0],
+                frustumCulled: settings.frustumCulled ?? true,
+                appearance: settings.appearance === 'circular' ? WawaVFX.AppearanceMode.Circular : WawaVFX.AppearanceMode.Square,
+                easeFunction: settings.easeFunction ?? 'easeLinear',
+                shadingHooks: settings.shadingHooks ?? {},
+            };
+            // Convert blending mode string to THREE constant
+            if (settings.blendingMode) {
+                switch (settings.blendingMode) {
+                    case 'normal':
+                        internalSettings.blendingMode = THREE.NormalBlending;
+                        break;
+                    case 'additive':
+                        internalSettings.blendingMode = THREE.AdditiveBlending;
+                        break;
+                    case 'subtractive':
+                        internalSettings.blendingMode = THREE.SubtractiveBlending;
+                        break;
+                    case 'multiply':
+                        internalSettings.blendingMode = THREE.MultiplyBlending;
+                        break;
+                }
+            }
+            // Load alpha map if specified
+            if (settings.alphaMapPath && !alphaMap) {
+                const world = this.getWorld();
+                if (world) {
+                    const assetPath = new AssetPath(settings.alphaMapPath);
+                    const loadedTexture = await resourceManager.loadTexture(assetPath);
+                    if (loadedTexture) {
+                        alphaMap = loadedTexture;
+                    }
+                }
+            }
+            // Load geometry if specified, or use default cube for mesh mode
+            if (settings.geometryPath && !geometry) {
+                const world = this.getWorld();
+                if (world) {
+                    const assetPath = new AssetPath(settings.geometryPath);
+                    const gltf = await resourceManager.loadModel(assetPath);
+                    if (gltf && gltf.scene.children[0] instanceof THREE.Mesh) {
+                        geometry = gltf.scene.children[0].geometry;
+                    }
+                }
+            }
+            else if (settings.renderMode === 'mesh') {
+                // Use default cube geometry for mesh mode
+                geometry = new THREE.BoxGeometry(1, 1, 1);
+            }
+            // Create VFXParticles
+            vfxParticles = new WawaVFX.VFXParticles(name, internalSettings, WawaVFX.vfxStore.getState(), alphaMap, geometry);
+            // Add to scene
+            const world = this.getWorld();
+            if (world) {
+                world.scene.add(vfxParticles.getMesh());
+            }
+            this.vfxParticlesRegistry.set(name, vfxParticles);
+        }
+        return vfxParticles;
+    }
+    /**
+     * Spawn a VFX effect from code (supports single or multiple emitters/particles)
+     * @param name Unique name for the VFX
+     * @param particlesSettings Particle system settings (single or array)
+     * @param emitterSettings Emitter settings (single or array)
+     * @param options Spawn options
+     * @returns Array of created emitters
+     */
+    async spawnVFX(name, particlesSettings, emitterSettings, options = {}) {
+        // Normalize to arrays
+        const particlesArray = Array.isArray(particlesSettings) ? particlesSettings : [particlesSettings];
+        const emittersArray = Array.isArray(emitterSettings) ? emitterSettings : [emitterSettings];
+        const definition = new VFXDefinition({
+            name,
+            particles: particlesArray,
+            emitters: emittersArray,
+        });
+        return this.spawnVFXFromDefinition(definition, options);
+    }
+    /**
+     * Spawn a VFX effect from a definition (v2 API for multiple emitters/particles)
+     * @param definition VFX definition with multiple particles and emitters
+     * @param options Spawn options
+     * @returns Array of created emitters
+     */
+    async spawnVFXFromDefinition(definition, options = {}) {
+        const emitters = [];
+        // Create all particle systems
+        for (let i = 0; i < definition.particles.length; i++) {
+            const particleSettings = definition.particles[i];
+            const particleName = `${definition.name}_particles_${i}`;
+            await this.getOrCreateVFXParticles(particleName, particleSettings);
+        }
+        // Create all emitters
+        for (let i = 0; i < definition.emitters.length; i++) {
+            const emitterSettings = definition.emitters[i];
+            const particlesIndex = emitterSettings.particlesIndex ?? 0;
+            const particleName = `${definition.name}_particles_${particlesIndex}`;
+            const emitter = new WawaVFX.VFXEmitter(particleName, emitterSettings, WawaVFX.vfxStore.getState());
+            // Set transform
+            if (options.position) {
+                emitter.position.copy(options.position);
+            }
+            if (options.rotation) {
+                emitter.rotation.copy(options.rotation);
+            }
+            if (options.scale) {
+                emitter.scale.copy(options.scale);
+            }
+            // Attach to root
+            this.rootComponent.add(emitter);
+            // Calculate lifetime from settings
+            const emitterLifetime = emitterSettings.duration ?? 1;
+            const particleLifetime = emitterSettings.particlesLifetime?.[1] ?? 1;
+            const totalLifetime = emitterSettings.loop ? Infinity : (emitterLifetime + particleLifetime);
+            // Track the VFX
+            const vfxInfo = {
+                emitter,
+                attachTime: this.getWorld()?.getGameTime() ?? 0,
+                lifetime: totalLifetime,
+            };
+            this.attachedVFX.push(vfxInfo);
+            // Start emitting
+            emitter.startEmitting(true);
+            emitters.push(emitter);
+        }
+        return emitters;
+    }
+    /**
+     * Spawn a VFX effect from a JSON file path (JSON-based)
+     * @param vfxPath Path to VFX definition JSON
+     * @param options Spawn options
+     * @returns Array of created emitters (v2) or single emitter (v1 compatibility)
+     */
+    async spawnVFXFromPath(vfxPath, options = {}) {
+        const assetPath = new AssetPath(vfxPath);
+        const json = await resourceManager.loadJsonObject(assetPath);
+        if (!json) {
+            throw new Error(`Failed to load VFX definition from ${vfxPath}`);
+        }
+        const definition = VFXDefinition.fromJSON(json);
+        return this.spawnVFXFromDefinition(definition, options);
+    }
+    /**
+     * Get the VFX store for advanced usage
+     */
+    getVFXStore() {
+        return WawaVFX.vfxStore.getState();
+    }
+    /**
+     * Get information about all currently attached VFX
+     */
+    getAttachedVFX() {
+        return this.attachedVFX;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GlobalParticleManager.js","sourceRoot":"","sources":["../../../src/actors/GlobalParticleManager.ts"],"names":[],"mappings":"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"}

package/dist/src/actors/Pawn.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Pawn - controllable actor that receives input from a PlayerController.
+ *
+ * Detailed explanation:
+ * - Owns a movement component and an optional camera component that define how it moves and what it sees.
+ * - Implements helper methods like `beginFire` and `jump` that delegate to equipped components.
+ * - Designed to be subclassed for game-specific behaviors while keeping input routing consistent.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Possess an instance with `PlayerController` to drive it via keyboard or gamepad.
+ * - Override movement or input functions to integrate custom mechanics.
+ * - Use the provided delegates to intercept input events if you need bespoke logic.
+ */
+import { Delegate } from '../utils/Delegate.js';
+import { Actor } from './Actor.js';
+import type { ActorOptions } from './Actor.js';
+import type { PlayerController } from './PlayerController.js';
+import type { IEquipment } from '../components/gameplay/Equipment.js';
+import type { BasePawnMovementComponent } from '../components/movement/BasePawnMovementComponent.js';
+import type { GamepadAxis, GamepadAxisEventDelegate, GamepadButton, GamepadButtonEventDelegate, KeyboardEventDelegate, MouseButton, MouseEventDelegate } from '../systems/InputManager.js';
+import type * as THREE from 'three';
+export interface PawnOptions extends ActorOptions {
+    movementComponent: BasePawnMovementComponent | null;
+    camera: THREE.Camera | null;
+    enableDirectionalLightFollowing?: boolean;
+}
+export type PawnPossessDelegate = Delegate<[Pawn, PlayerController], void>;
+export declare class Pawn<TOptions extends PawnOptions = PawnOptions> extends Actor<TOptions> {
+    private _movementComponent;
+    private playerController;
+    readonly onKeyDown: KeyboardEventDelegate;
+    readonly onKeyUp: KeyboardEventDelegate;
+    readonly onMouseDown: MouseEventDelegate;
+    readonly onMouseUp: MouseEventDelegate;
+    readonly onGamepadButtonDown: GamepadButtonEventDelegate;
+    readonly onGamepadButtonUp: GamepadButtonEventDelegate;
+    readonly onGamepadAxisChange: GamepadAxisEventDelegate;
+    readonly onPossessed: PawnPossessDelegate;
+    readonly onUnpossessed: PawnPossessDelegate;
+    private directionalLight;
+    constructor(options: TOptions);
+    /**
+     * Gets the movement component
+     */
+    get movementComponent(): BasePawnMovementComponent | null;
+    /**
+     * Sets the movement component
+     */
+    set movementComponent(component: BasePawnMovementComponent | null);
+    protected getExportedConstructor(): any;
+    /**
+       * Adds input for forward/backward movement
+       * @param value The input value (positive for forward, negative for backward)
+       * @param isAbsolute True if the value represents an absolute amount, false if it represents a speed/rate
+       */
+    addForwardInput(value: number, isAbsolute?: boolean): void;
+    /**
+       * Adds input for right/left movement
+       * @param value The input value (positive for right, negative for left)
+       * @param isAbsolute True if the value represents an absolute amount, false if it represents a speed/rate
+       */
+    addRightInput(value: number, isAbsolute?: boolean): void;
+    /**
+       * Adds input for looking up/down
+       * @param value The input value (positive for up, negative for down)
+       * @param isAbsolute True if the value represents an absolute amount, false if it represents a speed/rate
+       */
+    addLookUpInput(value: number, isAbsolute?: boolean): void;
+    /**
+       * Adds input for looking right/left
+       * @param value The input value (positive for right, negative for left)
+       * @param isAbsolute True if the value represents an absolute amount, false if it represents a speed/rate
+       */
+    addLookRightInput(value: number, isAbsolute?: boolean): void;
+    /**
+       * Adds input for zooming in/out
+       * @param value The input value (positive for zoom in, negative for zoom out)
+       * @param isAbsolute True if the value represents an absolute amount, false if it represents a speed/rate
+       */
+    addZoomInput(value: number, isAbsolute?: boolean): void;
+    /**
+       * Sets the player controller that controls this pawn
+       * @param playerController The player controller instance or null to clear
+       */
+    setPlayerController(playerController: PlayerController | null): void;
+    /**
+       * Gets the player controller that controls this pawn
+       * @returns The current player controller or null if none
+       */
+    getPlayerController(): PlayerController | null;
+    /**
+       * Jumps the pawn
+       */
+    jump(strength?: number): void;
+    /**
+     * Stops the pawn's jump
+     */
+    stopJump(): void;
+    /**
+       * Fire or use the equipment
+       * @returns True if the fire was successful, false otherwise
+       */
+    beginFire(): boolean;
+    /**
+       * Stop firing or using the equipment
+       * @returns True if the stop was successful, false otherwise
+       */
+    endFire(): boolean;
+    /**
+       * Fire or use the equipment
+       * @returns True if the fire was successful, false otherwise
+       */
+    beginAltFire(): boolean;
+    /**
+       * Stop firing or using the equipment
+       * @returns True if the stop was successful, false otherwise
+       */
+    endAltFire(): boolean;
+    /**
+       * Reload the equipped weapon
+       * @returns True if the reload was initiated, false otherwise
+       */
+    reload(): boolean;
+    /**
+     * Sets the world transform of the pawn
+     * @param transform The transform to set
+     */
+    setWorldTransform(transform: {
+        position?: THREE.Vector3;
+        rotation?: THREE.Euler;
+        scale?: THREE.Vector3;
+    }): void;
+    /**
+     * Handles key down events from the input system
+     * @param e The keyboard event
+     * @returns True if the event was handled, false otherwise
+     */
+    handleKeyDown(e: KeyboardEvent): boolean;
+    /**
+     * Handles key up events from the input system
+     * @param e The keyboard event
+     * @returns True if the event was handled, false otherwise
+     */
+    handleKeyUp(e: KeyboardEvent): boolean;
+    /**
+     * Handles mouse down events from the input system
+     * @param button The mouse button
+     * @param e The mouse event
+     * @returns True if the event was handled, false otherwise
+     */
+    handleMouseDown(button: MouseButton, e: MouseEvent): boolean;
+    /**
+     * Handles mouse up events from the input system
+     * @param button The mouse button
+     * @param e The mouse event
+     * @returns True if the event was handled, false otherwise
+     */
+    handleMouseUp(button: MouseButton, e: MouseEvent): boolean;
+    /**
+     * Handles gamepad button down events
+     * @param gamepadIndex The index of the gamepad
+     * @param buttonIndex The button that was pressed
+     * @param value The intensity of the button press (0.0 to 1.0)
+     * @returns True if the event was handled, false otherwise
+     */
+    handleGamepadButtonDown(gamepadIndex: number, buttonIndex: GamepadButton, value: number): boolean;
+    /**
+     * Handles gamepad button up events
+     * @param gamepadIndex The index of the gamepad
+     * @param buttonIndex The button that was released
+     * @returns True if the event was handled, false otherwise
+     */
+    handleGamepadButtonUp(gamepadIndex: number, buttonIndex: GamepadButton): boolean;
+    /**
+     * Handles gamepad axis change events
+     * @param gamepadIndex The index of the gamepad
+     * @param axisIndex The axis that changed
+     * @param value The new value of the axis (-1.0 to 1.0)
+     * @returns True if the event was handled, false otherwise
+     */
+    handleGamepadAxisChange(gamepadIndex: number, axisIndex: GamepadAxis, value: number): boolean;
+    isNetRelevant(): boolean;
+    getNetDynamicState(lastReplicatedState: object | null): object | null;
+    setNetDynamicState(dynamicState: object): void;
+    tickPrePhysics(deltaTime: number): void;
+    protected callEquipment(method: keyof IEquipment): boolean;
+    protected doBeginPlay(): void;
+    protected doEndPlay(): void;
+    private jumpCommand;
+    getEditorClassIcon(): string | null;
+}