@directivegames/genesys.js 3.1.24

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

@@ -0,0 +1,928 @@
+/**
+ * DoorComponent manages door state and animation logic.
+ *
+ * Detailed explanation:
+ * - Handles door state transitions (Closed, Opening, Open, Closing, Locked)
+ * - Implements transform-based animation for different door types using Tween.js
+ * - Provides proximity detection and interaction handling
+ * - Uses delegates for event notifications
+ * - Calculates appropriate pivot points from door geometry
+ * - Supports automatic proximity-based opening and manual key-based interaction
+ *
+ * Interaction Modes:
+ * - Proximity: Automatically opens when player enters range, closes when they exit
+ * - KeyPress: Requires player to be in proximity and press the interaction key
+ * - Remote: Reserved for future remote control implementation
+ *
+ * Proximity Detection:
+ * - Collision-based: Uses existing CollisionShapeComponent if found (more efficient)
+ * - Distance-based: Creates proximity trigger for distance calculation (fallback)
+ * - Automatically selects best method during initialization
+ *
+ * Animation System:
+ * - Transform-based animation independent of model pivot points
+ * - Smooth easing with configurable duration using Tween.js
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Attach to any actor that should behave like a door
+ * - Configure door type and animation parameters via options
+ * - Listen to door events using delegates (onDoorOpened, onDoorClosed, etc.)
+ * - Use open(), close(), toggle() methods for direct control
+ */
+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 _a;
+import * as TWEEN from '@tweenjs/tween.js';
+import * as THREE from 'three';
+import { Actor } from '../../actors/Actor.js';
+import { CollisionMeshType, PhysicsMotionType } from '../../physics/PhysicsTypes.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { DefaultCollisionProfile } from '../../systems/collision/CollisionTypes.js';
+import { Delegate } from '../../utils/Delegate.js';
+import { AsyncTaskWorker, IAsyncLoadableTag } from '../../utils/IAsyncLoadable.js';
+import { CollisionShapeComponent, CollisionShapeType } from '../CollisionShapeComponent.js';
+import { SceneComponent } from '../SceneComponent.js';
+import { GLTFMeshComponent } from '../visual/GLTFMeshComponent.js';
+export var DoorState;
+(function (DoorState) {
+    DoorState["Closed"] = "closed";
+    DoorState["Opening"] = "opening";
+    DoorState["Open"] = "open";
+    DoorState["Closing"] = "closing";
+    DoorState["Locked"] = "locked";
+})(DoorState || (DoorState = {}));
+/**
+ * Door animation types
+ */
+export var DoorType;
+(function (DoorType) {
+    /** Rotates around Y-axis (fully implemented) */
+    DoorType["Hinged"] = "hinged";
+    /** Slides along X-axis (fully implemented) */
+    DoorType["Sliding"] = "sliding";
+    /** Rotates and lifts upward (basic implementation) */
+    DoorType["Garage"] = "garage";
+    /** Multiple coordinated door panels (placeholder - uses hinged animation) */
+    DoorType["Double"] = "double";
+    /** Custom animation handled by external code via delegates */
+    DoorType["Custom"] = "custom";
+})(DoorType || (DoorType = {}));
+/**
+ * Door interaction methods
+ */
+export var DoorInteractionType;
+(function (DoorInteractionType) {
+    /** Automatically opens when player approaches, closes when they leave */
+    DoorInteractionType["Proximity"] = "proximity";
+    /** Requires player to be in proximity and press interaction key */
+    DoorInteractionType["KeyPress"] = "keypress";
+    /** Reserved for future remote control implementation */
+    DoorInteractionType["Remote"] = "remote";
+})(DoorInteractionType || (DoorInteractionType = {}));
+let DoorComponent = class DoorComponent extends SceneComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...SceneComponent.DEFAULT_OPTIONS,
+            doorType: DoorType.Hinged,
+            interactionType: DoorInteractionType.Proximity,
+            animationDuration: 1.0,
+            maxOpenAngle: 90,
+            slideDistance: 2.0,
+            slideDirection: new THREE.Vector3(1, 0, 0), // Default: slide to the right in local space
+            startLocked: false,
+            proximityRange: 2.0,
+            interactionKey: 'e',
+        };
+    }
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "inputManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // State management
+        Object.defineProperty(this, "currentState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: DoorState.Closed
+        });
+        Object.defineProperty(this, "animationProgress", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        // Tween.js animation
+        Object.defineProperty(this, "tweenGroup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new TWEEN.Group()
+        });
+        Object.defineProperty(this, "currentTween", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Transform tracking
+        Object.defineProperty(this, "initialTransform", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "doorPivotPoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "doorMesh", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "gltfMeshComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Interaction components
+        Object.defineProperty(this, "proximityTrigger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "existingCollisionShape", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "playersInRange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "isRegisteredForInput", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "useCollisionBasedProximity", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        // Proximity check optimization
+        Object.defineProperty(this, "proximityCheckTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "proximityCheckInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.25
+        }); // 4 times per second
+        // Event delegates
+        Object.defineProperty(this, "onDoorStartOpening", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onDoorStartClosing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onDoorOpened", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onDoorClosed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onDoorLocked", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onDoorUnlocked", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onInteractionAttempt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "_asyncTaskWorker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AsyncTaskWorker()
+        });
+        if (this.options.startLocked) {
+            this.currentState = DoorState.Locked;
+        }
+    }
+    beginPlay() {
+        super.beginPlay();
+        this._asyncTaskWorker.runTask(async () => {
+            // Initialize door geometry and pivot point
+            await this.initializeDoorGeometry();
+            // Set up proximity detection if needed
+            if (this.options.interactionType === DoorInteractionType.Proximity ||
+                this.options.interactionType === DoorInteractionType.KeyPress) {
+                this.setupProximityDetection();
+            }
+        });
+    }
+    endPlay() {
+        super.endPlay();
+        // Clean up input registration
+        if (this.isRegisteredForInput) {
+            const world = this.getActor()?.getWorld();
+            if (world) {
+                world.inputManager.removeInputHandler(this);
+                this.isRegisteredForInput = false;
+            }
+        }
+    }
+    // IAsyncLoadable implementation
+    async waitForLoad() {
+        await this._asyncTaskWorker.waitUntilComplete();
+    }
+    isLoading() {
+        return this._asyncTaskWorker.isRunning();
+    }
+    // end IAsyncLoadable implementation
+    tickPrePhysics(deltaTime) {
+        super.tickPrePhysics(deltaTime);
+        // Update tween animations
+        const gameTime = this.getWorld()?.getGameTime() ?? 0;
+        this.tweenGroup.update(gameTime * 1000); // Convert to milliseconds
+        // Proximity check optimization - only check 4 times per second
+        this.proximityCheckTimer += deltaTime;
+        if (this.proximityCheckTimer >= this.proximityCheckInterval) {
+            this.proximityCheckTimer = 0;
+            this.updateProximityCheck();
+        }
+        // Handle input registration for proximity-based interaction
+        this.updateInputRegistration();
+    }
+    /**
+     * Opens the door if it's not locked
+     */
+    open() {
+        if (this.currentState === DoorState.Locked) {
+            this.onDoorLocked.invoke(this);
+            return;
+        }
+        if (this.currentState === DoorState.Closed) {
+            this.startOpening();
+        }
+    }
+    /**
+     * Closes the door
+     */
+    close() {
+        if (this.currentState === DoorState.Open) {
+            this.startClosing();
+        }
+    }
+    /**
+     * Starts opening animation, can interrupt closing animation smoothly
+     */
+    startOpening() {
+        if (this.currentState === DoorState.Locked) {
+            this.onDoorLocked.invoke(this);
+            return;
+        }
+        this.currentState = DoorState.Opening;
+        // Fire the start opening event
+        this.onDoorStartOpening.invoke(this);
+        // Stop any existing tween
+        if (this.currentTween) {
+            this.currentTween.stop();
+            this.currentTween = null;
+        }
+        // Create tween from current progress to fully open (1.0)
+        const startProgress = this.animationProgress;
+        const targetProgress = 1.0;
+        const progressDelta = targetProgress - startProgress;
+        const duration = this.options.animationDuration * progressDelta * 1000; // Convert to milliseconds
+        const tweenData = { progress: startProgress };
+        this.currentTween = new TWEEN.Tween(tweenData, this.tweenGroup)
+            .to({ progress: targetProgress }, duration)
+            .easing(TWEEN.Easing.Cubic.InOut)
+            .onUpdate(() => {
+            this.animationProgress = tweenData.progress;
+            this.applyDoorTransform(this.animationProgress);
+        })
+            .onComplete(() => {
+            this.currentState = DoorState.Open;
+            this.currentTween = null;
+            this.onDoorOpened.invoke(this);
+        })
+            .start();
+    }
+    /**
+     * Starts closing animation, can interrupt opening animation smoothly
+     */
+    startClosing() {
+        this.currentState = DoorState.Closing;
+        // Fire the start closing event
+        this.onDoorStartClosing.invoke(this);
+        // Stop any existing tween
+        if (this.currentTween) {
+            this.currentTween.stop();
+            this.currentTween = null;
+        }
+        // Create tween from current progress to fully closed (0.0)
+        const startProgress = this.animationProgress;
+        const targetProgress = 0.0;
+        const progressDelta = Math.abs(targetProgress - startProgress);
+        const duration = this.options.animationDuration * progressDelta * 1000; // Convert to milliseconds
+        const tweenData = { progress: startProgress };
+        this.currentTween = new TWEEN.Tween(tweenData, this.tweenGroup)
+            .to({ progress: targetProgress }, duration)
+            .easing(TWEEN.Easing.Cubic.InOut)
+            .onUpdate(() => {
+            this.animationProgress = tweenData.progress;
+            this.applyDoorTransform(this.animationProgress);
+        })
+            .onComplete(() => {
+            this.currentState = DoorState.Closed;
+            this.currentTween = null;
+            this.onDoorClosed.invoke(this);
+        })
+            .start();
+    }
+    /**
+     * Toggles the door state
+     */
+    toggle() {
+        if (this.isOpen()) {
+            this.close();
+        }
+        else {
+            this.open();
+        }
+    }
+    /**
+     * Locks the door
+     */
+    lock() {
+        this.currentState = DoorState.Locked;
+        this.onDoorLocked.invoke(this);
+    }
+    /**
+     * Unlocks the door
+     */
+    unlock() {
+        if (this.currentState === DoorState.Locked) {
+            this.currentState = DoorState.Closed;
+            this.onDoorUnlocked.invoke(this);
+        }
+    }
+    /**
+     * Checks if the door is currently open
+     */
+    isOpen() {
+        return this.currentState === DoorState.Open;
+    }
+    /**
+     * Checks if the door is currently locked
+     */
+    isLocked() {
+        return this.currentState === DoorState.Locked;
+    }
+    /**
+     * Checks if the door is currently animating
+     */
+    isAnimating() {
+        return this.currentState === DoorState.Opening || this.currentState === DoorState.Closing;
+    }
+    /**
+     * Gets the current door state
+     */
+    getState() {
+        return this.currentState;
+    }
+    // IInputHandler implementation
+    handleKeyDown(e) {
+        if (e.key.toLowerCase() === this.options.interactionKey.toLowerCase()) {
+            if (this.playersInRange.size > 0) {
+                this.onInteractionAttempt.invoke(this);
+                this.toggle();
+                return true;
+            }
+        }
+        return false;
+    }
+    handleKeyUp(e) { return false; }
+    handleMouseDown(button, e) { return false; }
+    handleMouseUp(button, e) { return false; }
+    handleMouseMove(e) { return false; }
+    handleMouseClick(button, e) { return false; }
+    setInputManager(manager) {
+        this.inputManager = manager;
+    }
+    /**
+     * Initializes door geometry and calculates pivot point
+     */
+    async initializeDoorGeometry() {
+        const actor = this.getActor();
+        if (!actor) {
+            return;
+        }
+        // Get the GLTF mesh component from the root scene component hierarchy
+        const gltfComponent = actor.rootComponent.getComponent(GLTFMeshComponent);
+        if (!gltfComponent) {
+            console.warn('[DoorComponent] No GLTF mesh component found');
+            return;
+        }
+        // Store reference to the GLTF mesh component for animation
+        this.gltfMeshComponent = gltfComponent;
+        // Also search for existing CollisionShapeComponent for proximity detection
+        const existingCollisionShape = actor.rootComponent.getComponent(CollisionShapeComponent);
+        if (existingCollisionShape) {
+            this.existingCollisionShape = existingCollisionShape;
+            this.useCollisionBasedProximity = true;
+        }
+        else {
+            this.useCollisionBasedProximity = false;
+        }
+        // Wait for model to load
+        await gltfComponent.waitForLoad();
+        const model = gltfComponent.getModel();
+        if (!model) {
+            console.log('[DoorComponent] Model failed to load');
+            return;
+        }
+        // Store initial transform of the GLTF mesh component (what we'll be animating)
+        this.initialTransform = {
+            position: gltfComponent.position.clone(),
+            rotation: gltfComponent.rotation.clone(),
+            scale: gltfComponent.scale.clone()
+        };
+        // Find the door mesh and calculate pivot point
+        this.findDoorMesh(model);
+        this.calculatePivotPoint();
+        // Fix physics options - doors should be kinematic (can be moved by code but not physics)
+        gltfComponent.replacePhysicsOptions({
+            enabled: true,
+            motionType: PhysicsMotionType.KinematicPositionBased,
+            generateCollisionEvents: false, // We don't need collision events from the door itself
+            collisionMeshType: CollisionMeshType.ConvexHull,
+            density: 1.0
+        });
+    }
+    /**
+     * Finds the main door mesh in the model
+     */
+    findDoorMesh(model) {
+        let bestCandidate = null;
+        let bestScore = 0;
+        model.traverse((object) => {
+            if (object instanceof THREE.Mesh) {
+                // Score potential door meshes based on name and dimensions
+                let score = 0;
+                const name = object.name.toLowerCase();
+                if (name.includes('door'))
+                    score += 10;
+                if (name.includes('panel'))
+                    score += 5;
+                if (name.includes('leaf'))
+                    score += 5;
+                // Check dimensions (doors are typically tall and rectangular)
+                const bbox = new THREE.Box3().setFromObject(object);
+                const size = bbox.getSize(new THREE.Vector3());
+                if (size.y > 1.5 && size.y > size.x && size.y > size.z) {
+                    score += 5; // Tall object
+                }
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestCandidate = object;
+                }
+            }
+        });
+        this.doorMesh = bestCandidate;
+    }
+    /**
+     * Calculates the appropriate pivot point for door animation
+     */
+    calculatePivotPoint() {
+        if (!this.doorMesh)
+            return;
+        const bbox = new THREE.Box3().setFromObject(this.doorMesh);
+        switch (this.options.doorType) {
+            case DoorType.Hinged:
+                // Pivot at the edge of the door (typically left side)
+                const center1 = new THREE.Vector3();
+                bbox.getCenter(center1);
+                this.doorPivotPoint = new THREE.Vector3(bbox.min.x, bbox.min.y, center1.z);
+                break;
+            case DoorType.Sliding:
+                // No pivot needed for sliding doors
+                this.doorPivotPoint = null;
+                break;
+            case DoorType.Garage:
+                // Pivot at the bottom edge
+                const center2 = new THREE.Vector3();
+                bbox.getCenter(center2);
+                this.doorPivotPoint = new THREE.Vector3(center2.x, bbox.min.y, bbox.min.z);
+                break;
+            case DoorType.Double:
+                // For double doors, use center as pivot (each door swings outward)
+                const center3 = new THREE.Vector3();
+                bbox.getCenter(center3);
+                this.doorPivotPoint = new THREE.Vector3(center3.x, bbox.min.y, center3.z);
+                break;
+        }
+    }
+    /**
+     * Sets up proximity detection for door interaction
+     */
+    setupProximityDetection() {
+        const actor = this.getActor();
+        if (!actor)
+            return;
+        if (this.useCollisionBasedProximity && this.existingCollisionShape) {
+            this.setupCollisionBasedProximity();
+        }
+        else {
+            this.setupDistanceBasedProximity();
+        }
+    }
+    /**
+     * Sets up collision-based proximity detection using existing CollisionShapeComponent
+     */
+    setupCollisionBasedProximity() {
+        if (!this.existingCollisionShape)
+            return;
+        // Bind to overlap events for proximity detection (using sensor/trigger volumes)
+        this.existingCollisionShape.onOverlapWith.add((thisComponent, otherComponent, collisionEvent) => {
+            const otherActor = otherComponent.getActor();
+            if (otherActor && this.isPlayerPawn(otherActor)) {
+                this.playersInRange.add(otherActor);
+                this.handleProximityChange();
+            }
+        });
+        // Bind to overlap end events for proximity exit detection
+        this.existingCollisionShape.onStopOverlappingWith.add((thisComponent, otherComponent, collisionEvent) => {
+            const otherActor = otherComponent.getActor();
+            if (otherActor && this.isPlayerPawn(otherActor)) {
+                this.playersInRange.delete(otherActor);
+                this.handleProximityChange();
+            }
+        });
+    }
+    /**
+     * Sets up collision-based proximity detection with a new proximity trigger that only detects player pawns
+     */
+    async setupDistanceBasedProximity() {
+        const actor = this.getActor();
+        if (!actor)
+            return;
+        // Calculate trigger position based on door geometry
+        const doorPosition = actor.rootComponent.position.clone();
+        // Wait for door geometry to be initialized so we can use the door bounds
+        let triggerPosition = doorPosition.clone();
+        if (this.doorMesh) {
+            // If we have door mesh info, position the trigger at the center of the door panel
+            this.doorMesh.geometry.computeBoundingBox();
+            const boundingBox = this.doorMesh.geometry.boundingBox;
+            if (boundingBox) {
+                // Get the center of the door panel in local space
+                const doorCenter = new THREE.Vector3();
+                boundingBox.getCenter(doorCenter);
+                // Transform to world space
+                const worldCenter = doorCenter.clone();
+                this.doorMesh.localToWorld(worldCenter);
+                // Use the door center as the trigger position
+                triggerPosition.copy(worldCenter);
+                triggerPosition.y = doorPosition.y + 1.25; // Keep the vertical center
+            }
+        }
+        else {
+            // Fallback: offset the trigger towards the door panel (assuming standard door orientation)
+            // For a hinged door, offset forward by about half a door width (typical door is ~0.8m wide)
+            const doorForward = new THREE.Vector3(0, 0, 1); // Towards the door panel
+            const offsetDistance = 0.4; // Half a typical door width
+            triggerPosition.add(doorForward.multiplyScalar(offsetDistance));
+            triggerPosition.y += 1.25; // Center vertically
+        }
+        // Create a simple actor to hold the trigger component
+        const world = actor.getWorld();
+        if (world) {
+            // Create the trigger component that only overlaps with Pawn channel (player pawns)
+            this.proximityTrigger = new CollisionShapeComponent({
+                shapeType: CollisionShapeType.Cube,
+                scale: new THREE.Vector3(this.options.proximityRange * 2, 2.5, this.options.proximityRange * 2),
+                physicsOptions: {
+                    enabled: true,
+                    motionType: PhysicsMotionType.Static,
+                    generateCollisionEvents: true,
+                    // Use Trigger profile which only generates overlap events, no blocking
+                    collisionProfile: DefaultCollisionProfile.Trigger
+                }
+            });
+            // Bind to overlap events for proximity detection - this will only trigger for Pawn channel objects
+            this.proximityTrigger.onOverlapWith.add((thisComponent, otherComponent, collisionEvent) => {
+                const otherActor = otherComponent.getActor();
+                if (otherActor && this.isPlayerPawn(otherActor)) {
+                    this.playersInRange.add(otherActor);
+                    this.handleProximityChange();
+                }
+            });
+            // Bind to overlap end events for proximity exit detection
+            this.proximityTrigger.onStopOverlappingWith.add((thisComponent, otherComponent, collisionEvent) => {
+                const otherActor = otherComponent.getActor();
+                if (otherActor && this.isPlayerPawn(otherActor)) {
+                    this.playersInRange.delete(otherActor);
+                    this.handleProximityChange();
+                }
+            });
+            // Create an actor with a simple root component
+            const triggerActor = new Actor({
+                position: triggerPosition,
+                rootComponent: new SceneComponent({})
+            });
+            // Add the trigger as a child component
+            triggerActor.rootComponent.add(this.proximityTrigger);
+            // Add to world
+            world.addActors(triggerActor);
+            // Switch to collision-based proximity since we're now using collision events
+            this.useCollisionBasedProximity = true;
+        }
+        else {
+            console.log('[DoorComponent] Could not get world to add trigger');
+        }
+    }
+    /**
+     * Checks if an actor is a player pawn (controlled by a PlayerController)
+     */
+    isPlayerPawn(actor) {
+        return actor.getPlayerController() !== null;
+    }
+    /**
+     * Handles proximity change events for automatic doors
+     */
+    handleProximityChange() {
+        if (this.options.interactionType !== DoorInteractionType.Proximity)
+            return;
+        const hasPlayersInRange = this.playersInRange.size > 0;
+        // Player entered range - open door (can interrupt closing animation)
+        if (hasPlayersInRange && (this.currentState === DoorState.Closed || this.currentState === DoorState.Closing)) {
+            this.startOpening();
+        }
+        // Player left range - close door (can interrupt opening animation)
+        else if (!hasPlayersInRange && (this.currentState === DoorState.Open || this.currentState === DoorState.Opening)) {
+            this.startClosing();
+        }
+    }
+    /**
+     * Proximity check - handles both collision-based and distance-based detection
+     */
+    updateProximityCheck() {
+        const world = this.getActor()?.getWorld();
+        if (!world)
+            return;
+        const previousCount = this.playersInRange.size;
+        if (this.useCollisionBasedProximity) {
+            // For collision-based proximity, detection is handled entirely by collision events
+            // No additional processing needed here
+        }
+        else {
+            // For distance-based proximity, do full distance calculation
+            this.updateDistanceBasedProximity();
+        }
+        // Handle automatic proximity-based interaction
+        this.handleProximityChange();
+    }
+    /**
+     * Updates distance-based proximity detection
+     */
+    updateDistanceBasedProximity() {
+        if (!this.proximityTrigger)
+            return;
+        const world = this.getActor()?.getWorld();
+        if (!world)
+            return;
+        const triggerPosition = this.proximityTrigger.getWorldPosition(new THREE.Vector3());
+        const range = this.options.proximityRange;
+        const previousCount = this.playersInRange.size;
+        // Clear current players in range
+        this.playersInRange.clear();
+        // Check all actors in the world that are player pawns
+        const playerActors = world.getActorsByPredicate(actor => this.isPlayerPawn(actor));
+        for (const actor of playerActors) {
+            const actorPosition = actor.rootComponent.getWorldPosition(new THREE.Vector3());
+            const distance = triggerPosition.distanceTo(actorPosition);
+            if (distance <= range) {
+                this.playersInRange.add(actor);
+                // Log when player enters range for the first time
+                if (previousCount === 0) {
+                }
+            }
+        }
+    }
+    /**
+     * Updates input registration based on proximity
+     */
+    updateInputRegistration() {
+        const shouldBeRegistered = this.playersInRange.size > 0 &&
+            this.options.interactionType === DoorInteractionType.KeyPress;
+        if (shouldBeRegistered && !this.isRegisteredForInput) {
+            const world = this.getActor()?.getWorld();
+            if (world) {
+                // Register with high priority by adding to the beginning of the handler list
+                // This ensures the door component gets the input before other handlers
+                world.inputManager.addInputHandler(this);
+                const inputManager = world.inputManager;
+                const handlers = inputManager.inputHandlers;
+                const index = handlers.indexOf(this);
+                if (index > 0) {
+                    handlers.splice(index, 1); // Remove from current position
+                    handlers.unshift(this); // Add to beginning
+                }
+                this.isRegisteredForInput = true;
+            }
+        }
+        else if (!shouldBeRegistered && this.isRegisteredForInput) {
+            const world = this.getActor()?.getWorld();
+            if (world) {
+                // Unregister from input handling
+                world.inputManager.removeInputHandler(this);
+                this.isRegisteredForInput = false;
+            }
+        }
+    }
+    /**
+     * Applies transform to door based on animation progress
+     */
+    applyDoorTransform(progress) {
+        if (!this.initialTransform || !this.gltfMeshComponent)
+            return;
+        const actor = this.getActor();
+        if (!actor)
+            return;
+        switch (this.options.doorType) {
+            case DoorType.Hinged:
+                this.applyHingedTransform(this.gltfMeshComponent, progress);
+                break;
+            case DoorType.Sliding:
+                this.applySlidingTransform(this.gltfMeshComponent, actor, progress);
+                break;
+            case DoorType.Garage:
+                this.applyGarageTransform(this.gltfMeshComponent, progress);
+                break;
+            case DoorType.Double:
+                this.applyDoubleTransform(this.gltfMeshComponent, progress);
+                break;
+            case DoorType.Custom:
+                // Custom doors handle their own animation via delegates
+                // No built-in transform is applied
+                break;
+        }
+    }
+    /**
+     * Applies hinged door animation
+     */
+    applyHingedTransform(gltfComponent, progress) {
+        if (!this.initialTransform)
+            return;
+        const openAngle = THREE.MathUtils.degToRad(this.options.maxOpenAngle) * progress;
+        // Reset to initial position and rotation
+        gltfComponent.position.copy(this.initialTransform.position);
+        gltfComponent.rotation.copy(this.initialTransform.rotation);
+        // For hinged doors, we rotate around Y-axis in local space
+        // Transform this axis by the Actor's world rotation to make it work with any door orientation
+        const actor = this.getActor();
+        if (actor) {
+            const actorWorldRotation = actor.getWorldRotation();
+            // The hinge axis in local space (Y-axis)
+            const localHingeAxis = new THREE.Vector3(0, 1, 0);
+            // Transform the hinge axis by the Actor's world rotation
+            const worldHingeAxis = localHingeAxis.clone();
+            worldHingeAxis.applyEuler(actorWorldRotation);
+            // Create a quaternion representing rotation around the transformed hinge axis
+            const hingeQuaternion = new THREE.Quaternion();
+            hingeQuaternion.setFromAxisAngle(worldHingeAxis, openAngle);
+            // Apply this rotation to the mesh's current rotation
+            const currentQuaternion = new THREE.Quaternion().setFromEuler(gltfComponent.rotation);
+            currentQuaternion.multiply(hingeQuaternion);
+            gltfComponent.rotation.setFromQuaternion(currentQuaternion);
+        }
+        else {
+            // Fallback: just apply Y rotation (original behavior)
+            gltfComponent.rotation.y += openAngle;
+        }
+    }
+    /**
+     * Applies sliding door animation
+     */
+    applySlidingTransform(gltfComponent, actor, progress) {
+        if (!this.initialTransform)
+            return;
+        const slideOffset = this.options.slideDistance * progress;
+        // Reset to initial position
+        gltfComponent.position.copy(this.initialTransform.position);
+        gltfComponent.rotation.copy(this.initialTransform.rotation);
+        // Use the configurable slide direction in the door's local coordinate system
+        // Transform it by the Actor's world rotation to make it work with any door orientation
+        const slideDirection = this.options.slideDirection ?? new THREE.Vector3(1, 0, 0);
+        const worldSlideVector = slideDirection.clone().normalize();
+        // Apply the Actor's world rotation to transform the slide direction from local to world space
+        // This makes the sliding direction relative to the door's actual orientation in the world
+        const actorWorldRotation = actor.getWorldRotation();
+        worldSlideVector.applyEuler(actorWorldRotation);
+        // Apply sliding offset in the calculated world direction
+        const slideVector = worldSlideVector.multiplyScalar(slideOffset);
+        gltfComponent.position.add(slideVector);
+    }
+    /**
+     * Applies garage door animation (combination of rotation and translation)
+     */
+    applyGarageTransform(gltfComponent, progress) {
+        if (!this.initialTransform)
+            return;
+        const maxAngle = THREE.MathUtils.degToRad(90) * progress;
+        const liftHeight = 2.0 * progress;
+        // Reset to initial position
+        gltfComponent.position.copy(this.initialTransform.position);
+        gltfComponent.rotation.copy(this.initialTransform.rotation);
+        // Rotate and lift
+        gltfComponent.rotation.x -= maxAngle;
+        gltfComponent.position.y += liftHeight;
+    }
+    /**
+     * Applies double door animation
+     */
+    applyDoubleTransform(gltfComponent, progress) {
+        // For now, treat as single hinged door
+        // In Phase 3, this will coordinate multiple door panels
+        this.applyHingedTransform(gltfComponent, progress);
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_Door';
+    }
+};
+_a = IAsyncLoadableTag;
+Object.defineProperty(DoorComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        doorType: { select: Object.values(DoorType) },
+        interactionType: { select: Object.values(DoorInteractionType) }
+    }
+});
+DoorComponent = __decorate([
+    EngineClass('DoorComponent'),
+    __metadata("design:paramtypes", [Object])
+], DoorComponent);
+export { DoorComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DoorComponent.js","sourceRoot":"","sources":["../../../../src/components/gameplay/DoorComponent.ts"],"names":[],"mappings":"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"}