@directivegames/genesys.js 3.1.24

package/dist/games/deprecated/advanced-grid-demo.js

@@ -0,0 +1,305 @@
+import * as dat from 'dat.gui';
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+export class AdvancedGridDemo extends ENGINE.BaseGameLoop {
+    constructor(container) {
+        super(container);
+        Object.defineProperty(this, "gui", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "skyboxComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "cubeActor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "cylinderActor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "cubeMaterial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "cylinderMaterial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.gui = new dat.GUI();
+        // Setup controls asynchronously after construction
+        this.setupControls().catch(console.error);
+    }
+    async preStart() {
+        // Create default lighting and player
+        ENGINE.GameBuilder.createDefaultLighting(this.world, false);
+        this.skyboxComponent = ENGINE.GameBuilder.createDefaultSkybox(this.world, {
+            ...ENGINE.SkyboxComponent.DEFAULT_OPTIONS,
+            envMapIntensity: 1.0,
+        });
+        // Create a player
+        const { pawn } = ENGINE.GameBuilder.createDefaultPawn(this.world);
+        pawn.rootComponent.setWorldPosition(new THREE.Vector3(0, 2, 5));
+        // Create demo objects
+        this.createDemoObjects();
+        // Create UI instructions
+        this.createInstructions();
+        // Add event listener for material switching
+        this.addEventListeners();
+    }
+    createDemoObjects() {
+        // Create grid texture for individual object materials
+        const gridTexture = new ENGINE.UrlTexture({
+            url: '@engine/assets/textures/Grid_10x10.png',
+            wrapS: THREE.RepeatWrapping,
+            wrapT: THREE.RepeatWrapping,
+        });
+        // Create scale-aware materials
+        this.cubeMaterial = ENGINE.MaterialHelpers.createScaleAwareGridMaterial(gridTexture, 1.0, // Grid scale for cube
+        1.0, new THREE.Color(0xffffff));
+        this.cylinderMaterial = ENGINE.MaterialHelpers.createScaleAwareGridMaterial(gridTexture, 1.0, // Grid scale for cylinder
+        1.0, new THREE.Color(0xffffff));
+        // Create only cube and cylinder as demo objects with scale-aware materials
+        const objects = [
+            {
+                name: 'Cube',
+                position: new THREE.Vector3(-3, 0.5, -8), // Y=0.5 so bottom sits at Y=0
+                modelUrl: '@engine/assets/models/SM_Cube.glb',
+                material: this.cubeMaterial
+            },
+            {
+                name: 'Cylinder',
+                position: new THREE.Vector3(3, 0.5, -8), // Y=0.5 so bottom sits at Y=0
+                modelUrl: '@engine/assets/models/SM_Cylinder.glb',
+                material: this.cylinderMaterial
+            }
+        ];
+        objects.forEach((obj) => {
+            const gltfComponent = new ENGINE.GLTFMeshComponent({
+                position: obj.position,
+                modelUrl: obj.modelUrl,
+                material: obj.material,
+                physicsOptions: {
+                    enabled: false // Disabled physics since there's no ground
+                }
+            });
+            // Position is already adjusted in the objects array to account for pivot at bottom
+            const actor = new ENGINE.Actor({
+                rootComponent: gltfComponent
+            });
+            actor.editorData.displayName = obj.name;
+            this.world.addActors(actor);
+            // Store references for scaling
+            if (obj.name === 'Cube') {
+                this.cubeActor = actor;
+            }
+            else if (obj.name === 'Cylinder') {
+                this.cylinderActor = actor;
+            }
+        });
+    }
+    createInstructions() {
+        const instructions = [
+            'Scale-Aware Grid Material Demo',
+            '',
+            'Controls:',
+            '• WASD - Move player',
+            '• Mouse - Look around',
+            '• Use GUI controls to adjust materials and settings',
+            '',
+            'Features:',
+            '• Scale-aware grid materials that maintain grid density',
+            '• Object scaling sliders (0.5x to 3x)',
+            '• Tone mapping controls',
+            '• HDR skybox selection',
+            '• Objects pivot from bottom (not center)',
+            '',
+            'Key Demo:',
+            'Scale the objects to see how the grid maintains its density!',
+            '• 1x scale = 1 grid cell per unit',
+            '• 2x scale = 4 grid cells per face (2x2)',
+            '• 0.5x scale = 1/4 grid cell per face',
+            '',
+            'This shows how the material tiles properly when objects are scaled,',
+            'maintaining consistent grid spacing in world space.'
+        ];
+        console.log(instructions.join('\n'));
+    }
+    addEventListeners() {
+        // Input handling moved to tick method
+    }
+    tick(tickTime) {
+        super.tick(tickTime);
+        // No keyboard input or material animations needed for this demo
+    }
+    async setupControls() {
+        const toneMappingOptions = {
+            'No Tone Mapping': THREE.NoToneMapping,
+            'Linear Tone Mapping': THREE.LinearToneMapping,
+            'Reinhard Tone Mapping': THREE.ReinhardToneMapping,
+            'Cineon Tone Mapping': THREE.CineonToneMapping,
+            'ACES Filmic Tone Mapping': THREE.ACESFilmicToneMapping,
+            'AGX Tone Mapping': THREE.AgXToneMapping,
+            'Neutral Tone Mapping': THREE.NeutralToneMapping,
+            'Custom Tone Mapping': THREE.CustomToneMapping
+        };
+        // Helper function to get the name of the current tone mapping method
+        const getToneMappingName = (value) => {
+            for (const [name, toneMappingValue] of Object.entries(toneMappingOptions)) {
+                if (toneMappingValue === value) {
+                    return name;
+                }
+            }
+            return 'Reinhard Tone Mapping'; // fallback
+        };
+        // Get current values from renderer
+        const settings = {
+            toneMapping: getToneMappingName(this.renderer.renderer.toneMapping),
+            exposure: 0.6
+        };
+        // Set the renderer to our desired default
+        this.renderer.renderer.toneMappingExposure = 0.6;
+        // Create tone mapping folder
+        const toneMappingFolder = this.gui.addFolder('Tone Mapping');
+        toneMappingFolder.open();
+        // Add algorithm selection
+        toneMappingFolder.add(settings, 'toneMapping', Object.keys(toneMappingOptions)).onChange((value) => {
+            const toneMappingValue = toneMappingOptions[value];
+            this.renderer.renderer.toneMapping = toneMappingValue;
+        }).name('Algorithm');
+        // Add exposure control
+        toneMappingFolder.add(settings, 'exposure', 0.1, 3.0, 0.1).onChange((value) => {
+            this.renderer.renderer.toneMappingExposure = value;
+        }).name('Exposure');
+        // Dynamically detect available skybox textures
+        const skyboxOptions = await this.detectAvailableSkyboxTextures();
+        const skyboxNames = Object.keys(skyboxOptions);
+        // Current skybox settings
+        const skyboxSettings = {
+            skyboxTexture: skyboxNames.find(name => name.toLowerCase().includes('venice')) ?? skyboxNames[0] ?? 'Citrus Orchard Road',
+            envMapIntensity: 1.0,
+            backgroundBlurriness: 0.06
+        };
+        // Set the scene background blur to our desired default
+        this.world.scene.backgroundBlurriness = 0.06;
+        // Create skybox folder
+        const skyboxFolder = this.gui.addFolder('Skybox');
+        skyboxFolder.open();
+        // Add skybox texture dropdown
+        skyboxFolder.add(skyboxSettings, 'skyboxTexture', skyboxNames).onChange((value) => {
+            if (this.skyboxComponent) {
+                const textureUrl = skyboxOptions[value];
+                this.skyboxComponent.createTextureSkybox({
+                    textureUrl: textureUrl,
+                    envMapIntensity: skyboxSettings.envMapIntensity
+                });
+            }
+        });
+        // Apply initial skybox texture
+        if (this.skyboxComponent) {
+            const initialTextureUrl = skyboxOptions[skyboxSettings.skyboxTexture];
+            if (initialTextureUrl) {
+                this.skyboxComponent.createTextureSkybox({
+                    textureUrl: initialTextureUrl,
+                    envMapIntensity: skyboxSettings.envMapIntensity
+                });
+            }
+        }
+        // Add environment map intensity slider
+        skyboxFolder.add(skyboxSettings, 'envMapIntensity', 0.0, 2.0, 0.1).onChange((value) => {
+            if (this.skyboxComponent) {
+                const currentTexture = skyboxSettings.skyboxTexture;
+                const textureUrl = skyboxOptions[currentTexture];
+                this.skyboxComponent.createTextureSkybox({
+                    textureUrl: textureUrl,
+                    envMapIntensity: value
+                });
+            }
+        });
+        // Add background blurriness slider
+        skyboxFolder.add(skyboxSettings, 'backgroundBlurriness', 0.0, 1.0, 0.01).onChange((value) => {
+            this.world.scene.backgroundBlurriness = value;
+        }).name('Background Blur');
+        // Object scaling settings
+        const scaleSettings = {
+            cubeScale: 1.0,
+            cylinderScale: 1.0
+        };
+        // Create object controls folder
+        const objectFolder = this.gui.addFolder('Object Controls');
+        objectFolder.open();
+        // Add cube scale slider
+        objectFolder.add(scaleSettings, 'cubeScale', 0.5, 3.0, 0.1).onChange((value) => {
+            if (this.cubeActor && this.cubeMaterial) {
+                // Update object scale
+                this.cubeActor.rootComponent.scale.set(value, value, value);
+                // Update material scale uniform so grid maintains density
+                this.cubeMaterial.uniforms.objectScale.value.set(value, value, value);
+            }
+        }).name('Cube Scale');
+        // Add cylinder scale slider
+        objectFolder.add(scaleSettings, 'cylinderScale', 0.5, 3.0, 0.1).onChange((value) => {
+            if (this.cylinderActor && this.cylinderMaterial) {
+                // Update object scale
+                this.cylinderActor.rootComponent.scale.set(value, value, value);
+                // Update material scale uniform so grid maintains density
+                this.cylinderMaterial.uniforms.objectScale.value.set(value, value, value);
+            }
+        }).name('Cylinder Scale');
+    }
+    async detectAvailableSkyboxTextures() {
+        // Only check for the skybox files that actually exist in the project
+        const knownSkyboxes = [
+            'citrus_orchard_road_puresky_2k.hdr',
+            'venice_sunset_4k.hdr'
+        ];
+        const availableSkyboxes = {};
+        const skyboxPath = '@engine/assets/textures/skybox/';
+        // Check each known skybox file
+        for (const filename of knownSkyboxes) {
+            try {
+                const fullPath = skyboxPath + filename;
+                // Try to fetch the file to see if it exists (suppress 404 errors)
+                const response = await fetch(fullPath, { method: 'HEAD' });
+                if (response.ok) {
+                    // Convert filename to a nice display name
+                    const displayName = filename
+                        .replace(/\.(hdr|exr)$/i, '') // Remove file extension
+                        .replace(/_/g, ' ') // Replace underscores with spaces
+                        .replace(/\b\w/g, l => l.toUpperCase()); // Capitalize first letter of each word
+                    availableSkyboxes[displayName] = fullPath;
+                }
+            }
+            catch (error) {
+                // File doesn't exist or can't be accessed, skip it silently
+                continue;
+            }
+        }
+        // If no skyboxes were found, add the default one
+        if (Object.keys(availableSkyboxes).length === 0) {
+            availableSkyboxes['Citrus Orchard Road Puresky 2k'] = '@engine/assets/textures/skybox/citrus_orchard_road_puresky_2k.hdr';
+        }
+        return availableSkyboxes;
+    }
+    destroy() {
+        if (this.gui) {
+            this.gui.destroy();
+        }
+        super.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advanced-grid-demo.js","sourceRoot":"","sources":["../../../games/deprecated/advanced-grid-demo.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,10 @@
+import * as ENGINE from 'genesys.js';
+export declare class AirplaneDemo extends ENGINE.BaseGameLoop {
+    private uiContainer;
+    constructor(container: HTMLElement);
+    protected preStart(): Promise<void>;
+    private createAirplane;
+    private createLighting;
+    private createUI;
+    destroy(): void;
+}

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

@@ -0,0 +1,136 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+export class AirplaneDemo extends ENGINE.BaseGameLoop {
+    constructor(container) {
+        super(container);
+        Object.defineProperty(this, "uiContainer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.uiContainer = document.createElement('div');
+    }
+    async preStart() {
+        this.createLighting();
+        this.createAirplane();
+        this.createUI();
+        ENGINE.GameBuilder.createDefaultGround(this.world, { size: new THREE.Vector3(5000, 10, 5000) });
+    }
+    createAirplane() {
+        // Create a pawn with airplane movement component
+        const airplaneMovementComponent = new ENGINE.AirplaneMovementComponent();
+        // Add a simple airplane model
+        const airplaneBody = new ENGINE.MeshComponent({
+            geometry: new THREE.CylinderGeometry(0.5, 0.5, 5, 8),
+            material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.BLUE }),
+            rotation: ENGINE.MathHelpers.makeRotationDegrees({ pitch: 90 }),
+        });
+        airplaneBody.castShadow = true;
+        // Add wings
+        const wingGeometry = new THREE.BoxGeometry(10, 0.2, 1);
+        const wingMaterial = new THREE.MeshStandardMaterial({ color: ENGINE.Color.RED });
+        const wings = new ENGINE.MeshComponent({
+            geometry: wingGeometry,
+            material: wingMaterial,
+            position: ENGINE.MathHelpers.makeVector({ up: 0 }),
+        });
+        wings.castShadow = true;
+        // Add tail wings
+        const tailWingGeometry = new THREE.BoxGeometry(3, 0.2, 0.7);
+        const tailWings = new ENGINE.MeshComponent({
+            geometry: tailWingGeometry,
+            material: wingMaterial,
+            position: ENGINE.MathHelpers.makeVector({ forward: -2.5 }),
+        });
+        tailWings.castShadow = true;
+        // Add vertical stabilizer
+        const stabilizer = new ENGINE.MeshComponent({
+            geometry: new THREE.BoxGeometry(0.2, 1.5, 1),
+            material: wingMaterial,
+            position: ENGINE.MathHelpers.makeVector({ forward: -2.5, up: 0.5 }),
+        });
+        stabilizer.castShadow = true;
+        // Create aircraft model
+        const pawn = new ENGINE.Pawn({
+            movementComponent: airplaneMovementComponent,
+            sceneComponents: [airplaneBody, wings, tailWings, stabilizer],
+            camera: null,
+        });
+        pawn.overridePhysicsOptions({ enabled: false }, true);
+        // Set pawn position
+        pawn.setWorldPosition(ENGINE.MathHelpers.makeVector({ up: 50, forward: 0 }));
+        const followComponent = new ENGINE.FollowComponent({
+            ...ENGINE.FollowComponent.DEFAULT_OPTIONS,
+            target: pawn.rootComponent,
+        });
+        followComponent.add(new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, 0.1, 1000));
+        pawn.rootComponent.add(followComponent);
+        // Create player controller and possess the pawn
+        const controller = new ENGINE.PlayerController();
+        controller.possess(pawn);
+        // Add pawn and controller to world
+        this.world.addActors(pawn, controller);
+    }
+    createLighting() {
+        // Add directional light (sun)
+        const directionalLight = new ENGINE.DirectionalLightComponent({
+            color: 0xffffff,
+            intensity: 1,
+            position: ENGINE.MathHelpers.makeVector({ forward: 50, right: 100, up: 100 }),
+            castShadow: true
+        });
+        // Configure shadows
+        directionalLight.configureShadowCamera({ left: -100, right: 100, top: 100, bottom: -100 });
+        directionalLight.configureShadow({ mapSize: 2048 });
+        const lightActor = new ENGINE.Actor();
+        lightActor.rootComponent.add(directionalLight);
+        this.world.addActors(lightActor);
+        // Add ambient light
+        const ambientLight = new ENGINE.AmbientLightComponent({
+            color: 0x666666,
+            intensity: 0.5
+        });
+        const ambientLightActor = new ENGINE.Actor();
+        ambientLightActor.rootComponent.add(ambientLight);
+        this.world.addActors(ambientLightActor);
+        // Add hemisphere light for sky
+        const hemiLight = new ENGINE.HemisphereLightComponent({
+            skyColor: 0x88aaff,
+            groundColor: 0x554422,
+            intensity: 0.5
+        });
+        const hemiLightActor = new ENGINE.Actor();
+        hemiLightActor.rootComponent.add(hemiLight);
+        this.world.addActors(hemiLightActor);
+    }
+    createUI() {
+        this.uiContainer.style.position = 'absolute';
+        this.uiContainer.style.top = '10px';
+        this.uiContainer.style.right = '10px';
+        this.uiContainer.style.padding = '10px';
+        this.uiContainer.style.backgroundColor = 'rgba(0, 0, 0, 0.5)';
+        this.uiContainer.style.color = 'white';
+        this.uiContainer.style.fontFamily = 'Arial, sans-serif';
+        this.uiContainer.style.borderRadius = '5px';
+        this.uiContainer.style.zIndex = '100';
+        this.uiContainer.style.minWidth = '200px';
+        // Instructions
+        const instructions = document.createElement('div');
+        instructions.innerHTML = `
+      <h3 style="margin-top: 0; text-align: center;">Airplane Controls</h3>
+      <div style="margin-bottom: 10px;">
+        <div><b>W/S</b>: Pitch down/up</div>
+        <div><b>A/D</b>: Bank left/right</div>
+        <div><b>Q/E</b>: Throttle up/down</div>
+      </div>
+    `;
+        this.uiContainer.appendChild(instructions);
+        this.container.appendChild(this.uiContainer);
+    }
+    destroy() {
+        this.container.removeChild(this.uiContainer);
+        super.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/games/deprecated/character-controller.d.ts

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

package/dist/games/deprecated/character-controller.js

@@ -0,0 +1,144 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+const movementType = ENGINE.CharacterMovementType.ThirdPerson;
+export class CharacterControllerDemo extends ENGINE.BaseGameLoop {
+    constructor(container) {
+        super(container);
+    }
+    async preStart() {
+        ENGINE.GameBuilder.createDefaultLighting(this.world);
+        ENGINE.GameBuilder.createDefaultPawnWithPhysics(this.world, movementType);
+        ENGINE.GameBuilder.createDefaultGround(this.world, { position: ENGINE.MathHelpers.makeVector({ up: -1 }) });
+        this.createEnvironment();
+    }
+    createEnvironment() {
+        const STATIC_PHYSICS = {
+            enabled: true,
+            motionType: ENGINE.PhysicsMotionType.Static,
+        };
+        const TRIGGER_PHYSICS = {
+            enabled: true,
+            motionType: ENGINE.PhysicsMotionType.Static,
+            collisionProfile: ENGINE.DefaultCollisionProfile.OverlapAll,
+        };
+        const DYNAMIC_PHYSICS = {
+            enabled: true,
+            motionType: ENGINE.PhysicsMotionType.Dynamic,
+        };
+        const MOVING_PLATFORM_PHYSICS = {
+            enabled: true,
+            motionType: ENGINE.PhysicsMotionType.KinematicVelocityBased,
+        };
+        const components = [
+            new ENGINE.MeshComponent({
+                position: ENGINE.MathHelpers.makeVector({ up: 2.5, forward: 20 }),
+                geometry: new THREE.BoxGeometry(5, 5, 5),
+                material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.RED }),
+                physicsOptions: TRIGGER_PHYSICS,
+            }),
+            new ENGINE.MeshComponent({
+                position: ENGINE.MathHelpers.makeVector({ up: 0, forward: 0, right: 40 }),
+                geometry: new THREE.BoxGeometry(5, 5, 5),
+                material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.ORANGE }),
+                physicsOptions: STATIC_PHYSICS,
+            }),
+            new ENGINE.MeshComponent({
+                position: ENGINE.MathHelpers.makeVector({ up: 0, forward: -20, right: 40 }),
+                geometry: new THREE.BoxGeometry(5, 5, 5),
+                material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.GRAY }),
+                physicsOptions: TRIGGER_PHYSICS,
+            }),
+            new ENGINE.MeshComponent({
+                position: ENGINE.MathHelpers.makeVector({ up: 0, forward: 20, right: -20 }),
+                rotation: ENGINE.MathHelpers.makeRotationDegrees({ pitch: -60 }),
+                geometry: new THREE.BoxGeometry(10, 25, 0.5),
+                material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.CYAN }),
+                physicsOptions: STATIC_PHYSICS,
+            }),
+            new ENGINE.MeshComponent({
+                position: ENGINE.MathHelpers.makeVector({ up: 0, forward: 20, right: -40 }),
+                rotation: ENGINE.MathHelpers.makeRotationDegrees({ pitch: -45 }),
+                geometry: new THREE.BoxGeometry(10, 25, 0.5),
+                material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.BROWN }),
+                physicsOptions: STATIC_PHYSICS,
+            }),
+            new ENGINE.MeshComponent({
+                position: ENGINE.MathHelpers.makeVector({ up: 0, forward: 20, right: -60 }),
+                rotation: ENGINE.MathHelpers.makeRotationDegrees({ pitch: -30 }),
+                geometry: new THREE.BoxGeometry(10, 25, 0.5),
+                material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.BLUE }),
+                physicsOptions: STATIC_PHYSICS,
+            }),
+            new ENGINE.MeshComponent({
+                position: ENGINE.MathHelpers.makeVector({ up: 0, forward: 20, right: 20 }),
+                geometry: new THREE.BoxGeometry(5, 5, 0.5),
+                material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.GREEN }),
+                physicsOptions: DYNAMIC_PHYSICS,
+            })
+        ];
+        for (let index = 0; index < 100; index++) {
+            let geometry = undefined;
+            const geometryType = Math.floor(Math.random() * 4);
+            switch (geometryType) {
+                case 0:
+                    geometry = new THREE.BoxGeometry(ENGINE.CHARACTER_WIDTH, ENGINE.CHARACTER_WIDTH, ENGINE.CHARACTER_WIDTH);
+                    break;
+                case 1:
+                    geometry = new THREE.SphereGeometry(ENGINE.CHARACTER_WIDTH / 2);
+                    break;
+                case 2:
+                    geometry = new THREE.CylinderGeometry(ENGINE.CHARACTER_WIDTH / 2, ENGINE.CHARACTER_WIDTH / 2, ENGINE.CHARACTER_HEIGHT);
+                    break;
+                case 3:
+                    geometry = new THREE.CapsuleGeometry(ENGINE.CHARACTER_WIDTH / 2, ENGINE.CHARACTER_HEIGHT);
+                    break;
+            }
+            components.push(new ENGINE.MeshComponent({
+                position: ENGINE.MathHelpers.makeVector({ up: 0, forward: (Math.random() * 2 - 1) * 50, right: (Math.random() * 2 - 1) * 50 }),
+                geometry,
+                material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.random() }),
+                physicsOptions: DYNAMIC_PHYSICS,
+            }));
+        }
+        for (const component of components) {
+            component.receiveShadow = true;
+            component.castShadow = true;
+        }
+        const meshActor = new ENGINE.Actor();
+        meshActor.rootComponent.add(...components);
+        // Use actor collision events instead of component collision events
+        meshActor.onOverlapWith.add((thisActor, thisActorComponent, otherActor, otherActorComponent, collisionEvent) => {
+            const meshComponent = thisActorComponent;
+            meshComponent.getMesh().material.color.set(ENGINE.Color.random());
+            if (otherActor instanceof ENGINE.Pawn) {
+                otherActor.jump(2);
+            }
+        });
+        this.world.addActors(meshActor);
+        // Add the moving platform independently
+        const movingPlatformPath = new THREE.CatmullRomCurve3([
+            new THREE.Vector3(-20, 0, 0),
+            new THREE.Vector3(0, 0, 20),
+            new THREE.Vector3(20, 0, 0),
+            new THREE.Vector3(0, 0, -20),
+        ], true);
+        const movingPlatform = new ENGINE.MeshComponent({
+            position: ENGINE.MathHelpers.makeVector({ up: 0 }),
+            geometry: new THREE.BoxGeometry(10, 1, 10),
+            material: new THREE.MeshStandardMaterial({ color: ENGINE.Color.YELLOW }),
+            physicsOptions: MOVING_PLATFORM_PHYSICS,
+        });
+        movingPlatform.castShadow = true;
+        const pathMovementComponent = new ENGINE.PathMovementComponent({
+            path: movingPlatformPath,
+            speed: 5,
+            loop: 'Loop',
+            autoStart: true,
+        });
+        movingPlatform.add(pathMovementComponent);
+        const movingPlatformActor = new ENGINE.Actor();
+        movingPlatformActor.rootComponent.add(movingPlatform);
+        this.world.addActors(movingPlatformActor);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"character-controller.js","sourceRoot":"","sources":["../../../games/deprecated/character-controller.ts"],"names":[],"mappings":"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"}