@directivegames/genesys.js 3.1.24

package/dist/games/deprecated/door-demo.d.ts

@@ -0,0 +1,30 @@
+import * as ENGINE from 'genesys.js';
+/**
+ * Demo game to test door and switch functionality
+ */
+export declare class DoorDemo extends ENGINE.BaseGameLoop {
+    private doors;
+    private switches;
+    private triggerZones;
+    private separateDoor;
+    private uiContainer;
+    protected preStart(): Promise<void>;
+    private createTestCollisionShape;
+    private createTestDoors;
+    private createTestSwitches;
+    /**
+     * Creates a jump pad trigger zone
+     */
+    private createTestTriggerZones;
+    private createSeparateDoor;
+    private spawnFallingCube;
+    private setupDirectTesting;
+    private createUIHints;
+    /**
+     * 🏷️ Creates additional doors to demonstrate tag-based control
+     * Shows how multiple doors can be controlled with a single switch using tags
+     */
+    private createTaggedDoors;
+    destroy(): void;
+    protected postStart(): void;
+}

package/dist/games/deprecated/door-demo.js

@@ -0,0 +1,562 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+/**
+ * Demo game to test door and switch functionality
+ */
+export class DoorDemo extends ENGINE.BaseGameLoop {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "doors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "switches", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "triggerZones", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "separateDoor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "uiContainer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    async preStart() {
+        // Create basic scene
+        ENGINE.GameBuilder.createDefaultLighting(this.world);
+        ENGINE.GameBuilder.createDefaultGround(this.world);
+        // Create various types of doors for testing
+        this.createTestDoors();
+        // Create various types of switches for testing
+        this.createTestSwitches();
+        // 🏷️ Create additional doors to demonstrate multi-door control with tags
+        this.createTaggedDoors();
+        // Create trigger zones to test trigger zone system
+        this.createTestTriggerZones();
+        // Create test collision shape for debugging
+        this.createTestCollisionShape();
+        // Create player
+        const { pawn, controller } = ENGINE.GameBuilder.createDefaultPawnWithPhysics(this.world, ENGINE.CharacterMovementType.ThirdPerson);
+        pawn.rootComponent.position.set(0, 1, 10);
+    }
+    createTestCollisionShape() {
+        console.log('[DoorDemo] Creating test collision shape for debugging...');
+        // Create a test actor with CollisionShapeComponent as root component
+        const testCollisionActor = new ENGINE.Actor({
+            position: new THREE.Vector3(0, 0, 0), // At world origin (player starts at 0,1,10)
+            rootComponent: new ENGINE.CollisionShapeComponent({
+                shapeType: ENGINE.CollisionShapeType.Cube,
+                scale: new THREE.Vector3(10, 10, 10), // 10x10x10 cube for testing
+                physicsOptions: {
+                    enabled: true,
+                    generateCollisionEvents: true, // Required for overlap events
+                    collisionProfile: ENGINE.DefaultCollisionProfile.Trigger,
+                    motionType: ENGINE.PhysicsMotionType.Static,
+                }
+            })
+        });
+        // Add to world
+        this.world.addActors(testCollisionActor);
+        console.log('[DoorDemo] Test collision shape actor added at world origin (0, 0, 0)');
+    }
+    createTestDoors() {
+        console.log('[DoorDemo] Creating test doors...');
+        // Door 1: Hinged door - Manual interaction (proximity + key press)
+        const hingedDoor = new ENGINE.Actor({
+            position: new THREE.Vector3(0, 0, 0),
+            rootComponent: new ENGINE.GLTFMeshComponent({
+                modelUrl: '@engine/assets/dev/models/Props/Furniture/SM_Door_Closed.glb'
+            })
+        });
+        const hingedDoorComponent = new ENGINE.DoorComponent({
+            doorType: ENGINE.DoorType.Hinged,
+            interactionType: ENGINE.DoorInteractionType.KeyPress,
+            animationDuration: 1.5,
+            maxOpenAngle: 90,
+            slideDistance: 2.0, // Not used for hinged doors but required by interface
+            startLocked: false,
+            proximityRange: 2.5,
+            interactionKey: 'e'
+        });
+        hingedDoor.rootComponent.add(hingedDoorComponent);
+        // Door 2: Sliding door - Automatic proximity interaction
+        const slidingDoor = new ENGINE.Actor({
+            position: new THREE.Vector3(5, 0, 0), // Position to the right of the hinged door
+            rootComponent: new ENGINE.GLTFMeshComponent({
+                modelUrl: '@engine/assets/dev/models/Props/Furniture/SM_Door_Closed.glb'
+            })
+        });
+        const slidingDoorComponent = new ENGINE.DoorComponent({
+            doorType: ENGINE.DoorType.Sliding,
+            interactionType: ENGINE.DoorInteractionType.Proximity,
+            animationDuration: 2.0, // Slightly slower for smooth sliding
+            maxOpenAngle: 90, // Not used for sliding doors but required by interface
+            slideDistance: 2.5, // Distance to slide sideways
+            startLocked: false,
+            proximityRange: 3.0, // Larger range for automatic doors
+            interactionKey: 'e' // Not used for proximity doors but required by interface
+        });
+        slidingDoor.rootComponent.add(slidingDoorComponent);
+        // Door 3: Sliding door with collision-based detection - Demonstrates standalone DoorComponent usage
+        // This shows vanilla setup with CollisionShapeComponent for proximity detection
+        // Using SceneComponent as root with both mesh and collision as siblings
+        const vanillaSlidingDoorActor = new ENGINE.Actor({
+            position: new THREE.Vector3(-8, 0, 0), // Position to the left of other doors
+            rootComponent: new ENGINE.SceneComponent({
+            // Root scene component - acts as a pure transform container (SceneComponents don't have physics)
+            })
+        });
+        // Create the visual mesh component
+        const doorMesh = new ENGINE.GLTFMeshComponent({
+            modelUrl: '@engine/assets/dev/models/Props/Furniture/SM_Door_Closed.glb',
+            physicsOptions: {
+                enabled: true,
+                motionType: ENGINE.PhysicsMotionType.KinematicPositionBased, // Can be moved by code for animation
+                generateCollisionEvents: false, // Don't need collision events from the door itself
+                collisionMeshType: ENGINE.CollisionMeshType.ConvexHull,
+            }
+        });
+        // Create a CollisionShapeComponent for proximity detection (as sibling, not child)
+        const collisionShape = new ENGINE.CollisionShapeComponent({
+            shapeType: ENGINE.CollisionShapeType.Cube,
+            scale: new THREE.Vector3(10, 10, 10), // Larger area for easy testing
+            physicsOptions: {
+                enabled: true,
+                generateCollisionEvents: true, // Required for overlap events
+                collisionProfile: ENGINE.DefaultCollisionProfile.Trigger,
+                motionType: ENGINE.PhysicsMotionType.Static,
+            }
+        });
+        // Add both components as siblings to the root
+        vanillaSlidingDoorActor.rootComponent.add(doorMesh);
+        vanillaSlidingDoorActor.rootComponent.add(collisionShape);
+        // Create DoorComponent - it will automatically detect and use the CollisionShapeComponent
+        const vanillaSlidingDoorComponent = new ENGINE.DoorComponent({
+            doorType: ENGINE.DoorType.Sliding,
+            interactionType: ENGINE.DoorInteractionType.Proximity,
+            animationDuration: 2.0, // Smooth sliding animation
+            maxOpenAngle: 90, // Not used for sliding doors, but required by interface
+            slideDistance: 2.5, // Distance to slide sideways
+            proximityRange: 2.5, // Not used for collision-based, but kept for fallback
+            interactionKey: 'e', // Not used for proximity doors, but required by interface
+            startLocked: false,
+        });
+        // Add the DoorComponent to the actor
+        vanillaSlidingDoorActor.rootComponent.add(vanillaSlidingDoorComponent);
+        // Door 4: Sliding door - Same as door 2 but rotated 90 degrees
+        const rotatedSlidingDoor = new ENGINE.Actor({
+            position: new THREE.Vector3(0, 0, -5), // Position behind the other doors
+            rotation: new THREE.Euler(0, Math.PI / 2, 0), // 90 degrees rotation around Y-axis
+            rootComponent: new ENGINE.GLTFMeshComponent({
+                modelUrl: '@engine/assets/dev/models/Props/Furniture/SM_Door_Closed.glb'
+            })
+        });
+        const rotatedSlidingDoorComponent = new ENGINE.DoorComponent({
+            doorType: ENGINE.DoorType.Sliding,
+            interactionType: ENGINE.DoorInteractionType.Proximity,
+            animationDuration: 2.0, // Same as door 2
+            maxOpenAngle: 90, // Not used for sliding doors but required by interface
+            slideDistance: 2.5, // Same distance to slide sideways
+            startLocked: false,
+            proximityRange: 3.0, // Same range as door 2
+            interactionKey: 'e' // Not used for proximity doors but required by interface
+        });
+        rotatedSlidingDoor.rootComponent.add(rotatedSlidingDoorComponent);
+        // Door 5: Hinged door - Rotated 90 degrees to test hinge orientation issue
+        const rotatedHingedDoor = new ENGINE.Actor({
+            position: new THREE.Vector3(-10, 0, 0), // Position to the far left
+            rotation: new THREE.Euler(0, Math.PI / 2, 0), // 90 degrees rotation around Y-axis
+            rootComponent: new ENGINE.GLTFMeshComponent({
+                modelUrl: '@engine/assets/dev/models/Props/Furniture/SM_Door_Closed.glb'
+            })
+        });
+        const rotatedHingedDoorComponent = new ENGINE.DoorComponent({
+            doorType: ENGINE.DoorType.Hinged,
+            interactionType: ENGINE.DoorInteractionType.KeyPress,
+            animationDuration: 1.5,
+            maxOpenAngle: 90,
+            slideDistance: 2.0, // Not used for hinged doors but required by interface
+            startLocked: false,
+            proximityRange: 2.5,
+            interactionKey: 'e'
+        });
+        rotatedHingedDoor.rootComponent.add(rotatedHingedDoorComponent);
+        this.doors = [hingedDoor, slidingDoor, rotatedSlidingDoor, rotatedHingedDoor];
+        this.world.addActors(...this.doors);
+        this.world.addActors(vanillaSlidingDoorActor);
+        console.log('[DoorDemo] Door actors added to world (5 doors total: hinged, sliding, vanilla sliding, rotated sliding, and rotated hinged)');
+        // Add direct input handler for testing
+        this.setupDirectTesting(hingedDoor);
+        // Set up UI hints
+        this.createUIHints();
+    }
+    createTestSwitches() {
+        console.log('[DoorDemo] Creating test switches...');
+        // Switch 1: Toggle switch that spawns falling cubes
+        const cubeSpawnerSwitch = new ENGINE.Actor({
+            position: new THREE.Vector3(15, 1.2, 0), // Much further to the right, well away from doors
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.CylinderGeometry(0.5, 0.5, 0.2, 16),
+                material: new THREE.MeshStandardMaterial({ color: 0xff0000 }) // Red when off
+            })
+        });
+        const cubeSpawnerSwitchComponent = new ENGINE.SwitchComponent({
+            switchType: ENGINE.SwitchType.Toggle,
+            initialState: ENGINE.SwitchState.Off,
+            proximityRange: 2.0,
+            interactionKey: 'e'
+        });
+        cubeSpawnerSwitch.rootComponent.add(cubeSpawnerSwitchComponent);
+        // Set up event handlers
+        cubeSpawnerSwitchComponent.onActivated.add(() => {
+            console.log('[DoorDemo] Cube spawner switch activated - spawning falling cube!');
+            // Update visual feedback
+            const mesh = cubeSpawnerSwitch.rootComponent;
+            mesh.getMesh().material.color.set(0x00ff00); // Green when on
+            this.spawnFallingCube();
+        });
+        cubeSpawnerSwitchComponent.onDeactivated.add(() => {
+            console.log('[DoorDemo] Cube spawner switch deactivated');
+            // Update visual feedback
+            const mesh = cubeSpawnerSwitch.rootComponent;
+            mesh.getMesh().material.color.set(0xff0000); // Red when off
+        });
+        // Switch 2: Toggle switch that opens a separate door
+        const doorControlSwitch = new ENGINE.Actor({
+            position: new THREE.Vector3(-18, 1.2, 0), // Much further to the left, well away from doors
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.CylinderGeometry(0.5, 0.5, 0.2, 16),
+                material: new THREE.MeshStandardMaterial({ color: 0x0000ff }) // Blue when inactive
+            })
+        });
+        const doorControlSwitchComponent = new ENGINE.SwitchComponent({
+            switchType: ENGINE.SwitchType.Toggle,
+            initialState: ENGINE.SwitchState.Off,
+            proximityRange: 2.0,
+            interactionKey: 'e'
+        });
+        doorControlSwitch.rootComponent.add(doorControlSwitchComponent);
+        // Set up event handlers using the new tag system 🏷️
+        doorControlSwitchComponent.onActivated.add(() => {
+            console.log('[DoorDemo] Door control switch activated - opening door using tag system!');
+            // Update visual feedback
+            const mesh = doorControlSwitch.rootComponent;
+            mesh.getMesh().material.color.set(0xffff00); // Yellow when active
+            // 🏷️ NEW: Use tag system to find the door instead of direct reference
+            const doorActor = this.world.getFirstActorByTag('controllable-door');
+            if (doorActor) {
+                console.log('[DoorDemo] 🏷️ Door found by tag "controllable-door", calling open()...');
+                const doorComponent = doorActor.getComponent(ENGINE.DoorComponent);
+                doorComponent?.open();
+                console.log('[DoorDemo] Door opened successfully using tag system!');
+            }
+            else {
+                console.log('[DoorDemo] ERROR: No door found with tag "controllable-door"!');
+            }
+        });
+        doorControlSwitchComponent.onDeactivated.add(() => {
+            console.log('[DoorDemo] Door control switch deactivated - closing door using tag system!');
+            // Update visual feedback
+            const mesh = doorControlSwitch.rootComponent;
+            mesh.getMesh().material.color.set(0x0000ff); // Blue when inactive
+            // 🏷️ NEW: Use tag system to find the door instead of direct reference
+            const doorActor = this.world.getFirstActorByTag('controllable-door');
+            if (doorActor) {
+                console.log('[DoorDemo] 🏷️ Door found by tag "controllable-door", calling close()...');
+                const doorComponent = doorActor.getComponent(ENGINE.DoorComponent);
+                doorComponent?.close();
+                console.log('[DoorDemo] Door closed successfully using tag system!');
+            }
+        });
+        // Switch 3: Proximity switch that activates when player is near
+        const proximitySwitch = new ENGINE.Actor({
+            position: new THREE.Vector3(0, 1.2, 15), // Center but much further back, well away from doors
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(0.8, 0.4, 0.8), // Slightly larger box for visibility
+                material: new THREE.MeshStandardMaterial({ color: 0xff6600 }) // Orange when off
+            })
+        });
+        const proximitySwitchComponent = new ENGINE.SwitchComponent({
+            switchType: ENGINE.SwitchType.Proximity,
+            initialState: ENGINE.SwitchState.Off,
+            proximityRange: 3.0, // Larger range for automatic activation
+            interactionKey: 'e'
+        });
+        proximitySwitch.rootComponent.add(proximitySwitchComponent);
+        // Set up event handlers
+        proximitySwitchComponent.onActivated.add(() => {
+            console.log('[DoorDemo] Proximity switch activated - player entered range!');
+            console.log('[DoorDemo] 🎯 Welcome to the proximity zone! 🎯');
+            // Update visual feedback
+            const mesh = proximitySwitch.rootComponent;
+            mesh.getMesh().material.color.set(0x00ff00); // Green when on
+        });
+        proximitySwitchComponent.onDeactivated.add(() => {
+            console.log('[DoorDemo] Proximity switch deactivated - player left range!');
+            console.log('[DoorDemo] 👋 Goodbye! Come back anytime! 👋');
+            // Update visual feedback
+            const mesh = proximitySwitch.rootComponent;
+            mesh.getMesh().material.color.set(0xff6600); // Orange when off
+        });
+        this.switches = [cubeSpawnerSwitch, doorControlSwitch, proximitySwitch];
+        this.world.addActors(...this.switches);
+        // Create a separate door for the door control switch
+        this.createSeparateDoor();
+        console.log('[DoorDemo] Switch actors added to world (3 switches total: cube spawner, door control, and proximity)');
+    }
+    /**
+     * Creates a jump pad trigger zone
+     */
+    createTestTriggerZones() {
+        console.log('[DoorDemo] Creating jump pad trigger zone...');
+        // Jump Pad: Launches player upward when stepped on
+        const jumpPad = new ENGINE.Actor({
+            position: new THREE.Vector3(0, 0.5, 5) // Center area
+        });
+        const triggerComponent = new ENGINE.TriggerZoneComponent({
+            size: new THREE.Vector3(2, 1, 2),
+            filter: ENGINE.TriggerFilter.PlayerOnly,
+            enableDebugVisualization: true
+        });
+        triggerComponent.onActorEntered.add((actor, triggerZone) => {
+            console.log(`[DoorDemo] 🚀 JUMP PAD: Player ${actor.name} activated jump pad!`);
+            // Use a much stronger jump for jump pad effect
+            if (actor instanceof ENGINE.Pawn) {
+                const jumpPadStrength = 4.0; // 4x normal jump strength
+                actor.jump(jumpPadStrength);
+                console.log('[DoorDemo] 🎯 Player launched!');
+            }
+            else {
+                console.log('[DoorDemo] ❌ Actor is not a controllable pawn');
+            }
+        });
+        jumpPad.rootComponent.add(triggerComponent);
+        this.triggerZones = [jumpPad];
+        this.world.addActors(...this.triggerZones);
+        console.log('[DoorDemo] Jump pad trigger zone added to world');
+    }
+    createSeparateDoor() {
+        console.log('[DoorDemo] Creating separate door for switch control...');
+        // Create a separate door that will be controlled by the door control switch
+        // Using the new tag system for easier discovery
+        this.separateDoor = new ENGINE.Actor({
+            position: new THREE.Vector3(-18, 0, -8), // Near the door control switch but well offset
+            actorTags: ['controllable-door', 'entrance', 'switch-operated'], // 🏷️ NEW: Multiple tags for flexible discovery
+            rootComponent: new ENGINE.GLTFMeshComponent({
+                modelUrl: '@engine/assets/dev/models/Props/Furniture/SM_Door_Closed.glb'
+            })
+        });
+        const separateDoorComponent = new ENGINE.DoorComponent({
+            doorType: ENGINE.DoorType.Hinged,
+            interactionType: ENGINE.DoorInteractionType.KeyPress, // Can still be manually controlled
+            animationDuration: 1.5,
+            maxOpenAngle: 90,
+            slideDistance: 2.0, // Not used for hinged doors but required by interface
+            startLocked: false,
+            proximityRange: 2.5,
+            interactionKey: 'e'
+        });
+        this.separateDoor.rootComponent.add(separateDoorComponent);
+        console.log('[DoorDemo] Separate door actor created, adding to world...');
+        this.world.addActors(this.separateDoor);
+        console.log('[DoorDemo] Separate door added to world at position:', this.separateDoor.rootComponent.position.toArray());
+        console.log('[DoorDemo] 🏷️ Door tagged with multiple tags:', this.separateDoor.getActorTags());
+    }
+    spawnFallingCube() {
+        console.log('[DoorDemo] spawnFallingCube() called - creating physics cube...');
+        const spawnPosition = new THREE.Vector3(15 + (Math.random() - 0.5) * 2, // Near the cube spawner switch with some randomness
+        10, // High up so it falls down
+        (Math.random() - 0.5) * 4 // Random Z position
+        );
+        console.log('[DoorDemo] Cube spawn position:', spawnPosition);
+        // Create a physics-enabled cube that falls from above
+        const cubeActor = new ENGINE.Actor({
+            position: spawnPosition,
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(1, 1, 1),
+                material: new THREE.MeshStandardMaterial({
+                    color: Math.random() * 0xffffff // Random color
+                }),
+                physicsOptions: {
+                    enabled: true,
+                    motionType: ENGINE.PhysicsMotionType.Dynamic, // Affected by gravity
+                    generateCollisionEvents: true,
+                    density: 1.0
+                }
+            })
+        });
+        console.log('[DoorDemo] Created cube actor, adding to world...');
+        this.world.addActors(cubeActor);
+        console.log('[DoorDemo] Cube actor added to world successfully! Position:', cubeActor.rootComponent.position.toArray());
+        // Remove the cube after 10 seconds to avoid clutter
+        setTimeout(() => {
+            console.log('[DoorDemo] Cleaning up cube after 10 seconds...');
+            if (cubeActor.getWorld()) {
+                cubeActor.destroy();
+                console.log('[DoorDemo] Cube destroyed');
+            }
+        }, 10000);
+    }
+    setupDirectTesting(door) {
+        console.log('[DoorDemo] Setting up testing for door interaction');
+        // Add a simple input handler for testing only (T key for direct toggle)
+        const inputHandler = new ENGINE.BaseInputHandler();
+        inputHandler.handleKeyDown = (e) => {
+            // console.log('[DoorDemo] Key pressed:', e.key);
+            if (e.key.toLowerCase() === 't') {
+                console.log('[DoorDemo] Testing door toggle directly (bypassing proximity)');
+                const doorComponent = door.getComponent(ENGINE.DoorComponent);
+                doorComponent?.toggle();
+                return true;
+            }
+            // Don't handle 'E' key here - let the door component handle it based on proximity
+            return false;
+        };
+        this.world.inputManager.addInputHandler(inputHandler);
+        console.log('[DoorDemo] Testing input handler added (T key only)');
+    }
+    createUIHints() {
+        // Create a simple UI overlay with instructions
+        const container = document.createElement('div');
+        container.style.position = 'absolute';
+        container.style.top = '20px';
+        container.style.left = '20px';
+        container.style.backgroundColor = 'rgba(0, 0, 0, 0.7)';
+        container.style.color = 'white';
+        container.style.padding = '15px';
+        container.style.borderRadius = '5px';
+        container.style.fontFamily = 'Arial, sans-serif';
+        container.style.fontSize = '14px';
+        container.style.zIndex = '1000';
+        container.innerHTML = `
+      <h3>Demo Controls</h3>
+      <div style="margin-bottom: 8px;">
+        <strong>Movement:</strong> WASD + Mouse
+      </div>
+      <div style="margin-bottom: 8px;">
+        <strong>Interact:</strong> Press <kbd style="background: #333; padding: 2px 6px; border-radius: 3px;">E</kbd> when near interactive objects
+      </div>
+      <div style="margin-bottom: 8px;">
+        <strong>Test:</strong> Press <kbd style="background: #333; padding: 2px 6px; border-radius: 3px;">T</kbd> to test door directly
+      </div>
+    `;
+        // Store reference to the UI container
+        this.uiContainer = container;
+        // Add to the game container
+        const gameContainer = this.container;
+        gameContainer.appendChild(container);
+    }
+    /**
+     * 🏷️ Creates additional doors to demonstrate tag-based control
+     * Shows how multiple doors can be controlled with a single switch using tags
+     */
+    createTaggedDoors() {
+        console.log('[DoorDemo] 🏷️ Creating tagged doors for multi-door control demonstration...');
+        // Create multiple doors with the same tag for group control
+        const groupControlledDoorPositions = [
+            new THREE.Vector3(5, 0, -15),
+            new THREE.Vector3(10, 0, -15),
+            new THREE.Vector3(15, 0, -15)
+        ];
+        groupControlledDoorPositions.forEach((position, index) => {
+            const door = new ENGINE.Actor({
+                position,
+                actorTags: ['security-door', 'automated', `security-${index + 1}`], // 🏷️ Multiple tags for flexible grouping
+                rootComponent: new ENGINE.GLTFMeshComponent({
+                    modelUrl: '@engine/assets/dev/models/Props/Furniture/SM_Door_Closed.glb'
+                })
+            });
+            const doorComponent = new ENGINE.DoorComponent({
+                doorType: ENGINE.DoorType.Hinged,
+                interactionType: ENGINE.DoorInteractionType.Remote, // Only controlled remotely
+                animationDuration: 1.0,
+                maxOpenAngle: 90,
+                slideDistance: 2.0,
+                startLocked: false,
+                proximityRange: 2.0,
+                interactionKey: 'e'
+            });
+            door.rootComponent.add(doorComponent);
+            this.world.addActors(door);
+            console.log(`[DoorDemo] 🏷️ Security door ${index + 1} created with tags:`, door.getActorTags());
+        });
+        // Create a master switch to control all security doors
+        const masterSwitch = new ENGINE.Actor({
+            position: new THREE.Vector3(10, 1.2, -10),
+            actorTags: ['master-switch', 'control-panel', 'security-system'], // 🏷️ Multiple tags for the switch
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.SphereGeometry(0.6, 16, 8),
+                material: new THREE.MeshStandardMaterial({ color: 0x8B4513 }) // Brown
+            })
+        });
+        const masterSwitchComponent = new ENGINE.SwitchComponent({
+            switchType: ENGINE.SwitchType.Toggle,
+            initialState: ENGINE.SwitchState.Off,
+            proximityRange: 3.0,
+            interactionKey: 'e'
+        });
+        masterSwitch.rootComponent.add(masterSwitchComponent);
+        // Set up event handlers for multi-door control
+        masterSwitchComponent.onActivated.add(() => {
+            console.log('[DoorDemo] 🏷️ Master switch activated - opening ALL security doors!');
+            const mesh = masterSwitch.rootComponent;
+            mesh.getMesh().material.color.set(0x00ff00); // Green when active
+            // 🏷️ Find and control ALL doors with the security-door tag
+            const securityDoors = this.world.getActorsByTag('security-door');
+            console.log(`[DoorDemo] 🏷️ Found ${securityDoors.length} security doors to open`);
+            securityDoors.forEach((doorActor, index) => {
+                const doorComponent = doorActor.getComponent(ENGINE.DoorComponent);
+                doorComponent?.open();
+                console.log(`[DoorDemo] 🏷️ Security door ${index + 1} opened`);
+            });
+        });
+        masterSwitchComponent.onDeactivated.add(() => {
+            console.log('[DoorDemo] 🏷️ Master switch deactivated - closing ALL security doors!');
+            const mesh = masterSwitch.rootComponent;
+            mesh.getMesh().material.color.set(0x8B4513); // Brown when inactive
+            // 🏷️ Find and control ALL doors with the security-door tag
+            const securityDoors = this.world.getActorsByTag('security-door');
+            console.log(`[DoorDemo] 🏷️ Found ${securityDoors.length} security doors to close`);
+            securityDoors.forEach((doorActor, index) => {
+                const doorComponent = doorActor.getComponent(ENGINE.DoorComponent);
+                doorComponent?.close();
+                console.log(`[DoorDemo] 🏷️ Security door ${index + 1} closed`);
+            });
+        });
+        this.world.addActors(masterSwitch);
+        this.switches.push(masterSwitch);
+        console.log('[DoorDemo] 🏷️ Tagged doors and master switch system created successfully!');
+        console.log('[DoorDemo] 🏷️ Use the brown sphere switch to control all security doors at once');
+    }
+    destroy() {
+        // Clean up UI before calling parent destroy
+        if (this.uiContainer && this.uiContainer.parentElement) {
+            this.uiContainer.parentElement.removeChild(this.uiContainer);
+            this.uiContainer = null;
+        }
+        // Call parent destroy to handle other cleanup
+        super.destroy();
+    }
+    postStart() {
+        super.postStart();
+        console.log('Door & Switch Demo started!');
+        console.log('Controls: WASD + Mouse to move, E to interact, T to test door directly');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"door-demo.js","sourceRoot":"","sources":["../../../games/deprecated/door-demo.ts"],"names":[],"mappings":"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"}

package/dist/games/deprecated/fps-demo.d.ts

@@ -0,0 +1,9 @@
+import * as ENGINE from 'genesys.js';
+export declare class FPSDemo extends ENGINE.BaseGameLoop {
+    private weapon;
+    constructor(container: HTMLElement);
+    protected preStart(): Promise<void>;
+    private setupReloadEvents;
+    private setupAmmoLogging;
+    private logAmmoStatus;
+}