@directivegames/genesys.js 3.1.24

package/dist/src/components/CharacterStatsComponent.d.ts

@@ -0,0 +1,89 @@
+import { Delegate } from '../utils/Delegate.js';
+import { SceneComponent } from './SceneComponent.js';
+import type { SceneComponentOptions } from './SceneComponent.js';
+import type * as THREE from 'three';
+/**
+ * Interface defining the configuration options for character stats
+ */
+export interface CharacterStatsOptions extends SceneComponentOptions {
+    maxHealth?: number;
+    healthRegen?: number;
+    attackCooldown?: number;
+    attackRange?: number;
+    attackDamage?: number;
+    speed?: number;
+}
+/**
+ * Interface defining the hit information
+ */
+export interface DamageHitInfo {
+    /**
+     * The location of the hit
+     */
+    hitLocation: THREE.Vector3;
+    /**
+     * The normal of the hit on the surface of the hit actor
+     */
+    hitNormal: THREE.Vector3;
+}
+/**
+ * Component responsible for managing character statistics and combat-related attributes
+ */
+export declare class CharacterStatsComponent extends SceneComponent<CharacterStatsOptions> {
+    private maxHealth;
+    private currentHealth;
+    private healthRegen;
+    private isDead;
+    private attackCooldown;
+    private attackRange;
+    private attackDamage;
+    private speed;
+    readonly onHealthChanged: Delegate<[number, number], void>;
+    readonly onDeath: Delegate<[DamageHitInfo | undefined], void>;
+    protected handleDeath(hitInfo?: DamageHitInfo): void;
+    static get DEFAULT_OPTIONS(): CharacterStatsOptions;
+    constructor(options?: CharacterStatsOptions);
+    /**
+       * Called when the component starts playing
+       * @override
+       */
+    beginPlay(): void;
+    /**
+       * Called before physics simulation each frame
+       * @param deltaTime Time in seconds since the last frame
+       * @override
+       */
+    tickPrePhysics(deltaTime: number): void;
+    /**
+       * Updates the component's state
+       * @param deltaTime Time elapsed since the last frame in seconds
+       */
+    private tick;
+    /**
+       * Applies damage to the character
+       * @param amount Amount of damage to apply
+       * @param hitInfo Optional hit information
+       * @returns The actual amount of damage dealt
+       */
+    takeDamage(amount: number, hitInfo?: DamageHitInfo): number;
+    /**
+       * Heals the character
+       * @param amount Amount of healing to apply
+       * @returns The actual amount healed
+       */
+    heal(amount: number): number;
+    getMaxHealth(): number;
+    getCurrentHealth(): number;
+    getHealthRegen(): number;
+    getAttackCooldown(): number;
+    getAttackRange(): number;
+    getSpeed(): number;
+    getAttackDamage(): number;
+    setMaxHealth(value: number): void;
+    setHealthRegen(value: number): void;
+    setAttackCooldown(value: number): void;
+    setAttackRange(value: number): void;
+    setSpeed(value: number): void;
+    setAttackDamage(value: number): void;
+    getEditorClassIcon(): string | null;
+}

package/dist/src/components/CharacterStatsComponent.js

@@ -0,0 +1,207 @@
+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 CharacterStatsComponent_1;
+import { EngineClass } from '../systems/ClassRegistry.js';
+import { Delegate } from '../utils/Delegate.js';
+import { SceneComponent } from './SceneComponent.js';
+/**
+ * Component responsible for managing character statistics and combat-related attributes
+ */
+let CharacterStatsComponent = CharacterStatsComponent_1 = class CharacterStatsComponent extends SceneComponent {
+    // Custom death handler
+    handleDeath(hitInfo) {
+        const actor = this.getActor();
+        if (actor) {
+            actor.handleDeath(hitInfo);
+        }
+    }
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...SceneComponent.DEFAULT_OPTIONS,
+            maxHealth: 100,
+            healthRegen: 1,
+            attackCooldown: 1.0,
+            attackRange: 2.0,
+            attackDamage: 10,
+            speed: 5.0,
+        };
+    }
+    constructor(options = {}) {
+        super(options);
+        // Core stats
+        Object.defineProperty(this, "maxHealth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "currentHealth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "healthRegen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isDead", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        // Combat stats
+        Object.defineProperty(this, "attackCooldown", {
+            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, "attackDamage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Movement stats
+        Object.defineProperty(this, "speed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Events
+        Object.defineProperty(this, "onHealthChanged", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onDeath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        // Initialize with default values or provided options
+        this.maxHealth = options.maxHealth ?? CharacterStatsComponent_1.DEFAULT_OPTIONS.maxHealth;
+        this.currentHealth = this.maxHealth;
+        this.healthRegen = options.healthRegen ?? CharacterStatsComponent_1.DEFAULT_OPTIONS.healthRegen;
+        this.attackCooldown = options.attackCooldown ?? CharacterStatsComponent_1.DEFAULT_OPTIONS.attackCooldown;
+        this.attackRange = options.attackRange ?? CharacterStatsComponent_1.DEFAULT_OPTIONS.attackRange;
+        this.attackDamage = options.attackDamage ?? CharacterStatsComponent_1.DEFAULT_OPTIONS.attackDamage;
+        this.speed = options.speed ?? CharacterStatsComponent_1.DEFAULT_OPTIONS.speed;
+    }
+    /**
+       * Called when the component starts playing
+       * @override
+       */
+    beginPlay() {
+        super.beginPlay();
+        // Reset health and cooldowns when play begins
+        this.currentHealth = this.maxHealth;
+    }
+    /**
+       * Called before physics simulation each frame
+       * @param deltaTime Time in seconds since the last frame
+       * @override
+       */
+    tickPrePhysics(deltaTime) {
+        super.tickPrePhysics(deltaTime);
+        this.tick(deltaTime);
+    }
+    /**
+       * Updates the component's state
+       * @param deltaTime Time elapsed since the last frame in seconds
+       */
+    tick(deltaTime) {
+        // Apply health regeneration
+        if (this.currentHealth < this.maxHealth) {
+            this.heal(this.healthRegen * deltaTime);
+        }
+    }
+    /**
+       * Applies damage to the character
+       * @param amount Amount of damage to apply
+       * @param hitInfo Optional hit information
+       * @returns The actual amount of damage dealt
+       */
+    takeDamage(amount, hitInfo) {
+        if (this.isDead) {
+            return 0;
+        }
+        const previousHealth = this.currentHealth;
+        this.currentHealth = Math.max(0, this.currentHealth - amount);
+        this.onHealthChanged.invoke(this.currentHealth, this.maxHealth);
+        if (this.currentHealth <= 0) {
+            this.isDead = true;
+            this.onDeath.invoke(hitInfo);
+            this.handleDeath(hitInfo);
+        }
+        return previousHealth - this.currentHealth;
+    }
+    /**
+       * Heals the character
+       * @param amount Amount of healing to apply
+       * @returns The actual amount healed
+       */
+    heal(amount) {
+        if (this.isDead) {
+            return 0;
+        }
+        if (!amount) {
+            return 0;
+        }
+        const previousHealth = this.currentHealth;
+        this.currentHealth = Math.min(this.maxHealth, this.currentHealth + amount);
+        this.onHealthChanged.invoke(this.currentHealth, this.maxHealth);
+        return this.currentHealth - previousHealth;
+    }
+    // Getters
+    getMaxHealth() { return this.maxHealth; }
+    getCurrentHealth() { return this.currentHealth; }
+    getHealthRegen() { return this.healthRegen; }
+    getAttackCooldown() { return this.attackCooldown; }
+    getAttackRange() { return this.attackRange; }
+    getSpeed() { return this.speed; }
+    getAttackDamage() { return this.attackDamage; }
+    // Setters
+    setMaxHealth(value) {
+        this.maxHealth = value;
+        this.currentHealth = Math.min(this.currentHealth, this.maxHealth);
+        this.onHealthChanged.invoke(this.currentHealth, this.maxHealth);
+    }
+    setHealthRegen(value) { this.healthRegen = value; }
+    setAttackCooldown(value) { this.attackCooldown = value; }
+    setAttackRange(value) { this.attackRange = value; }
+    setSpeed(value) { this.speed = value; }
+    setAttackDamage(value) { this.attackDamage = value; }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_CharacterStats';
+    }
+};
+CharacterStatsComponent = CharacterStatsComponent_1 = __decorate([
+    EngineClass('CharacterStatsComponent'),
+    __metadata("design:paramtypes", [Object])
+], CharacterStatsComponent);
+export { CharacterStatsComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/components/CollisionShapeComponent.d.ts

@@ -0,0 +1,102 @@
+import { PrimitiveComponent } from './PrimitiveComponent.js';
+import type { PrimitiveComponentOptions } from './PrimitiveComponent.js';
+import type { EditorClassMeta, EditorPropertyChangedResult } from '../utils/EditorClassMeta.js';
+/**
+ * Supported collision shape types
+ */
+export declare enum CollisionShapeType {
+    Cube = "cube",
+    Sphere = "sphere"
+}
+/**
+ * Configuration options for the collision shape component
+ */
+export interface CollisionShapeComponentOptions extends PrimitiveComponentOptions {
+    /**
+     * The type of collision shape (cube or sphere)
+     * @default CollisionShapeType.Cube
+     */
+    shapeType?: CollisionShapeType;
+    /**
+     * Whether to enable debug visualization of the collision shape
+     * @default false
+     */
+    enableDebugVisualization?: boolean;
+}
+/**
+ * Component that adds collision detection capability to an actor
+ * Creates invisible collision geometry for physics interaction
+ *
+ * The collision shape size is controlled by the component's transform scale.
+ * Use setScale() on the component to resize the collision shape.
+ */
+export declare class CollisionShapeComponent extends PrimitiveComponent<CollisionShapeComponentOptions> {
+    /** The invisible mesh used for collision detection */
+    private collisionMesh;
+    /** The collision shape type */
+    private shapeType;
+    /** Whether debug visualization is currently enabled */
+    private debugVisualizationEnabled;
+    static readonly EDITOR_CLASS_META: EditorClassMeta;
+    static get DEFAULT_OPTIONS(): CollisionShapeComponentOptions;
+    /**
+     * Creates a new CollisionShapeComponent with the specified options
+     * @param options Configuration options for the collision shape
+     */
+    constructor(options?: CollisionShapeComponentOptions);
+    /**
+     * Create the collision mesh for the shape
+     * Creates a unit-sized shape that scales with the component's transform
+     */
+    private createCollisionMesh;
+    /**
+     * Update the visibility of the collision mesh based on current settings
+     */
+    private updateCollisionMeshVisibility;
+    /**
+     * Initialize component when play begins
+     */
+    beginPlay(): void;
+    /**
+     * Change the type of collision shape
+     * @param type The new collision shape type
+     */
+    setShapeType(type: CollisionShapeType): void;
+    /**
+     * Enable or disable debug visualization of the collision shape
+     * @param enabled Whether to enable debug visualization
+     */
+    setDebugVisualizationEnabled(enabled: boolean): void;
+    /**
+     * Toggle debug visualization on/off
+     */
+    toggleDebugVisualization(): void;
+    /**
+     * Get the current debug visualization state
+     * @returns Whether debug visualization is enabled
+     */
+    isDebugVisualizationEnabled(): boolean;
+    /**
+     * Enable or disable physics for this collision shape
+     * @param enable Whether to enable physics
+     */
+    enablePhysics(enable: boolean): void;
+    /**
+     * Get the collision shape type
+     * @returns The current collision shape type
+     */
+    getShapeType(): CollisionShapeType;
+    /**
+     * Handle property changes from the editor
+     * @param path The property path that changed
+     * @param value The new value
+     * @param result Result object for editor feedback
+     */
+    onEditorPropertyChanged(path: string, value: any, result: EditorPropertyChangedResult): void;
+    /**
+     * Called when the component is added to the world in the editor
+     * This ensures visibility is set correctly once the world context is available
+     */
+    onEditorAddToWorld(): void;
+    getEditorClassIcon(): string | null;
+}

package/dist/src/components/CollisionShapeComponent.js

@@ -0,0 +1,232 @@
+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 CollisionShapeComponent_1;
+import * as THREE from 'three';
+import { PhysicsMotionType } from '../physics/PhysicsTypes.js';
+import { EngineClass } from '../systems/ClassRegistry.js';
+import { MaterialHelpers } from '../utils/MaterialHelpers.js';
+import { PrimitiveComponent } from './PrimitiveComponent.js';
+/**
+ * Supported collision shape types
+ */
+export var CollisionShapeType;
+(function (CollisionShapeType) {
+    CollisionShapeType["Cube"] = "cube";
+    CollisionShapeType["Sphere"] = "sphere";
+})(CollisionShapeType || (CollisionShapeType = {}));
+/**
+ * Component that adds collision detection capability to an actor
+ * Creates invisible collision geometry for physics interaction
+ *
+ * The collision shape size is controlled by the component's transform scale.
+ * Use setScale() on the component to resize the collision shape.
+ */
+let CollisionShapeComponent = CollisionShapeComponent_1 = class CollisionShapeComponent extends PrimitiveComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...PrimitiveComponent.DEFAULT_OPTIONS,
+            shapeType: CollisionShapeType.Cube,
+            enableDebugVisualization: false,
+        };
+    }
+    /**
+     * Creates a new CollisionShapeComponent with the specified options
+     * @param options Configuration options for the collision shape
+     */
+    constructor(options = {}) {
+        super(options);
+        /** The invisible mesh used for collision detection */
+        Object.defineProperty(this, "collisionMesh", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** The collision shape type */
+        Object.defineProperty(this, "shapeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether debug visualization is currently enabled */
+        Object.defineProperty(this, "debugVisualizationEnabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Clean up any existing collision mesh (important for editor property changes)
+        if (this.collisionMesh) {
+            this.remove(this.collisionMesh);
+            this.collisionMesh = null;
+        }
+        // Set default values
+        this.shapeType = options.shapeType ?? CollisionShapeComponent_1.DEFAULT_OPTIONS.shapeType;
+        this.debugVisualizationEnabled = options.enableDebugVisualization ?? CollisionShapeComponent_1.DEFAULT_OPTIONS.enableDebugVisualization;
+        // Create the collision mesh
+        this.createCollisionMesh();
+    }
+    /**
+     * Create the collision mesh for the shape
+     * Creates a unit-sized shape that scales with the component's transform
+     */
+    createCollisionMesh() {
+        let collisionGeometry;
+        // Create unit-sized geometry based on shape type
+        // Scaling is handled by the component's transform scale
+        if (this.shapeType === CollisionShapeType.Sphere) {
+            collisionGeometry = new THREE.SphereGeometry(1, 8, 6); // Unit sphere (radius 1)
+        }
+        else {
+            // Default to cube
+            collisionGeometry = new THREE.BoxGeometry(1, 1, 1); // Unit cube (1x1x1)
+        }
+        // Always use wireframe material - visibility is controlled separately
+        const collisionMaterial = MaterialHelpers.createWireframeMaterial(0x00ff00); // Green wireframe
+        this.collisionMesh = new THREE.Mesh(collisionGeometry, collisionMaterial);
+        // Mark mesh as transient so it's not included in serialization
+        this.collisionMesh.setTransient(true);
+        // Set initial visibility
+        this.updateCollisionMeshVisibility();
+        this.add(this.collisionMesh);
+    }
+    /**
+     * Update the visibility of the collision mesh based on current settings
+     */
+    updateCollisionMeshVisibility() {
+        if (!this.collisionMesh)
+            return;
+        const world = this.getWorld();
+        const isEditorMode = world?.isEditorWorld ?? false;
+        const shouldShowDebug = this.debugVisualizationEnabled || isEditorMode;
+        this.collisionMesh.visible = shouldShowDebug;
+    }
+    /**
+     * Initialize component when play begins
+     */
+    beginPlay() {
+        super.beginPlay();
+        // Update visibility based on current editor state
+        this.updateCollisionMeshVisibility();
+    }
+    /**
+     * Change the type of collision shape
+     * @param type The new collision shape type
+     */
+    setShapeType(type) {
+        this.shapeType = type;
+        // Remove existing collision mesh
+        if (this.collisionMesh) {
+            this.remove(this.collisionMesh);
+            this.collisionMesh = null;
+        }
+        // Create new collision mesh
+        this.createCollisionMesh();
+        // Update physics if actor is playing
+        if (this.getActor()?.isPlaying() && this.isPhysicsEnabled()) {
+            // Use the safer physics update method
+            this.setPhysicsEnabled(false, false);
+            this.setPhysicsEnabled(true, false);
+        }
+    }
+    /**
+     * Enable or disable debug visualization of the collision shape
+     * @param enabled Whether to enable debug visualization
+     */
+    setDebugVisualizationEnabled(enabled) {
+        this.debugVisualizationEnabled = enabled;
+        this.updateCollisionMeshVisibility();
+    }
+    /**
+     * Toggle debug visualization on/off
+     */
+    toggleDebugVisualization() {
+        this.setDebugVisualizationEnabled(!this.debugVisualizationEnabled);
+    }
+    /**
+     * Get the current debug visualization state
+     * @returns Whether debug visualization is enabled
+     */
+    isDebugVisualizationEnabled() {
+        return this.debugVisualizationEnabled;
+    }
+    /**
+     * Enable or disable physics for this collision shape
+     * @param enable Whether to enable physics
+     */
+    enablePhysics(enable) {
+        if (!this.options.physicsOptions) {
+            this.options.physicsOptions = {
+                enabled: enable,
+                motionType: PhysicsMotionType.Dynamic,
+                density: 1.0
+            };
+        }
+        else {
+            this.options.physicsOptions.enabled = enable;
+        }
+        // Use the safer setPhysicsEnabled method from parent class
+        // This handles the physics registration/unregistration properly
+        this.setPhysicsEnabled(enable, false);
+    }
+    /**
+     * Get the collision shape type
+     * @returns The current collision shape type
+     */
+    getShapeType() {
+        return this.shapeType;
+    }
+    /**
+     * Handle property changes from the editor
+     * @param path The property path that changed
+     * @param value The new value
+     * @param result Result object for editor feedback
+     */
+    onEditorPropertyChanged(path, value, result) {
+        super.onEditorPropertyChanged(path, value, result);
+        if (path === 'shapeType') {
+            this.setShapeType(value);
+        }
+        else if (path === 'enableDebugVisualization') {
+            this.setDebugVisualizationEnabled(value);
+        }
+    }
+    /**
+     * Called when the component is added to the world in the editor
+     * This ensures visibility is set correctly once the world context is available
+     */
+    onEditorAddToWorld() {
+        super.onEditorAddToWorld();
+        // Update visibility now that world context is available
+        this.updateCollisionMeshVisibility();
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_CollisionShape';
+    }
+};
+Object.defineProperty(CollisionShapeComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        ...PrimitiveComponent.EDITOR_CLASS_META,
+        shapeType: { select: Object.values(CollisionShapeType) },
+    }
+});
+CollisionShapeComponent = CollisionShapeComponent_1 = __decorate([
+    EngineClass('CollisionShapeComponent'),
+    __metadata("design:paramtypes", [Object])
+], CollisionShapeComponent);
+export { CollisionShapeComponent };
+//# sourceMappingURL=data:application/json;base64,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