@directivegames/genesys.js 3.1.24

package/dist/games/vfx-demo.js

@@ -0,0 +1,821 @@
+import * as dat from 'dat.gui';
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+export class VFXDemo extends ENGINE.BaseGameLoop {
+    constructor(container) {
+        super(container);
+        Object.defineProperty(this, "centralParticleEmitter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "emitterShowcase", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "currentExplosionType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lastEmitterSwitchTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "raycaster", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Add emitterParams property
+        Object.defineProperty(this, "emitterParams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Add GUI property
+        Object.defineProperty(this, "gui", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Cache for particle emitters - initialize immediately
+        Object.defineProperty(this, "emitterCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.gui = new dat.GUI({ autoPlace: false });
+        container.appendChild(this.gui.domElement);
+        // Initialize all class properties
+        this.raycaster = new THREE.Raycaster();
+        this.emitterShowcase = [];
+        this.currentExplosionType = 0;
+        this.lastEmitterSwitchTime = 0;
+        this.emitterCache = new Map();
+        // Initialize emitterParams
+        this.emitterParams = {
+            central: {
+                particleColor: { r: 0, g: 0.66, b: 1 },
+                particleSize: 0.3,
+                particleSpeed: 10.0,
+                particleLifetime: 3.0,
+                emitterRate: 100,
+                emissionAngle: 15
+            },
+            showcase: {
+                'Fire Wall (Disc)': {
+                    particleColor: { r: 1, g: 0.33, b: 0 },
+                    particleSize: 0.5,
+                    particleSpeed: 5,
+                    particleLifetime: 1.2,
+                    emitterRate: 200,
+                    emissionRadius: 3.0
+                },
+                'Geyser (Cone)': {
+                    particleColor: { r: 0.66, g: 0.86, b: 1 },
+                    particleSize: 0.4,
+                    particleSpeed: 15,
+                    particleLifetime: 2.0,
+                    emitterRate: 150,
+                    emissionAngle: 10
+                },
+                'Smoke (Box)': {
+                    particleColor: { r: 0.53, g: 0.53, b: 0.53 },
+                    particleSize: 0.8,
+                    particleSpeed: 3,
+                    particleLifetime: 4.0,
+                    emitterRate: 50,
+                    emissionDimensions: { x: 2, y: 0.5, z: 2 }
+                },
+                'Spark Shower (Sphere)': {
+                    particleColor: { r: 1, g: 0.86, b: 0 },
+                    particleSize: 0.15,
+                    particleSpeed: 8,
+                    particleLifetime: 1.5,
+                    emitterRate: 80
+                }
+            }
+        };
+    }
+    async preStart() {
+        ENGINE.GameBuilder.createDefaultLighting(this.world);
+        this.createPlayer();
+        this.createEnvironment();
+        this.setupGUI();
+    }
+    createPlayer() {
+        const world = this.world;
+        const pawn = new ENGINE.Pawn({
+            movementComponent: new ENGINE.CharacterMovementComponent({
+                ...ENGINE.CharacterMovementComponent.DEFAULT_OPTIONS,
+                maxSpeed: 10,
+                lookRightSpeed: 0.1,
+                lookUpSpeed: 0.1
+            }),
+            position: ENGINE.MathHelpers.makeVector({ forward: -5, up: 50 }),
+            camera: new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, 0.1, 1000)
+        });
+        pawn.rootComponent.setLocalRotation(ENGINE.MathHelpers.makeRotationDegrees({ pitch: -75 }));
+        // Add a trail particle effect to the player using directional emission in a cone
+        const playerTrailEmitter = new ENGINE.ParticleEmitterComponent({
+            particleCount: 300,
+            particleSize: 0.2,
+            particleColor: new THREE.Color(0x00ffaa),
+            particleSpeed: 1.0,
+            particleLifetime: 0.8,
+            emitterPosition: ENGINE.MathHelpers.makeVector({ up: -1 }),
+            emitterRotation: new THREE.Euler(0, 0, 0),
+            emitterRate: 30,
+            // Use cone emission downward to create a trail
+            emissionDirection: new THREE.Vector3(0, -1, 0),
+            emissionShape: ENGINE.EmissionShape.Cone,
+            emissionAngle: 20
+        });
+        pawn.rootComponent.add(playerTrailEmitter);
+        const controller = new ENGINE.PlayerController({ noPointerLock: true });
+        controller.possess(pawn);
+        world.addActors(pawn, controller);
+        controller.onKeyDown.add((e) => {
+            if (e.key === 'Control') {
+                console.log('[VFX-Demo] Cycling explosion type');
+                this.cycleExplosionType();
+                return true;
+            }
+            return false;
+        });
+        controller.onMouseDown.add((button, e) => {
+            if (button === ENGINE.MouseButton.Left) {
+                const inputManager = controller.getInputManager();
+                if (inputManager) {
+                    // Get the current mouse position in NDC coordinates
+                    const mousePosition = inputManager.getMousePosition();
+                    // Convert screen position to world position
+                    const worldPosition = this.getWorldPositionFromScreen(mousePosition);
+                    // Create an explosion at the world position
+                    this.createExplosionEffect(worldPosition);
+                    return true; // Handled this event
+                }
+            }
+            return false;
+        });
+    }
+    createEnvironment() {
+        // Initialize with default values
+        this.emitterParams = {
+            central: {
+                particleColor: { r: 0, g: 0.66, b: 1 },
+                particleSize: 0.3,
+                particleSpeed: 10.0,
+                particleLifetime: 3.0,
+                emitterRate: 100,
+                emissionAngle: 15
+            },
+            showcase: {
+                'Fire Wall (Disc)': {
+                    particleColor: { r: 1, g: 0.33, b: 0 },
+                    particleSize: 0.5,
+                    particleSpeed: 5,
+                    particleLifetime: 1.2,
+                    emitterRate: 200,
+                    emissionRadius: 3.0
+                },
+                'Geyser (Cone)': {
+                    particleColor: { r: 0.66, g: 0.86, b: 1 },
+                    particleSize: 0.4,
+                    particleSpeed: 15,
+                    particleLifetime: 2.0,
+                    emitterRate: 150,
+                    emissionAngle: 10
+                },
+                'Smoke (Box)': {
+                    particleColor: { r: 0.53, g: 0.53, b: 0.53 },
+                    particleSize: 0.8,
+                    particleSpeed: 3,
+                    particleLifetime: 4.0,
+                    emitterRate: 50,
+                    emissionDimensions: { x: 2, y: 0.5, z: 2 }
+                },
+                'Spark Shower (Sphere)': {
+                    particleColor: { r: 1, g: 0.86, b: 0 },
+                    particleSize: 0.15,
+                    particleSpeed: 8,
+                    particleLifetime: 1.5,
+                    emitterRate: 80
+                }
+            }
+        };
+        // Setup terrain
+        this.setupTerrain(this.world);
+        // Create a central fountain particle effect
+        this.setupCentralFountain();
+        // Create particle effect showcase around the center
+        this.setupParticleShowcase();
+        // Set up a timer to cycle particle emitter demos
+        const timerSystem = this.world.timerSystem;
+        if (timerSystem) {
+            timerSystem.setInterval(() => {
+                this.cycleShowcaseEmitters();
+            }, 10, 'cycle-emitters');
+        }
+    }
+    setupTerrain(world) {
+        // Create a simple white plane
+        const planeActor = new ENGINE.Actor({ position: ENGINE.MathHelpers.makeVector({ up: -10 }) });
+        const planeWidth = 200;
+        const planeDepth = 200;
+        const planeGeometry = new THREE.PlaneGeometry(planeWidth, planeDepth);
+        const planeMaterial = new THREE.MeshStandardMaterial({ color: 0xffffff, side: THREE.DoubleSide }); // Ensure both sides are visible
+        const planeMeshComponent = new ENGINE.MeshComponent({
+            geometry: planeGeometry,
+            material: planeMaterial,
+            physicsOptions: {
+                enabled: true,
+                motionType: ENGINE.PhysicsMotionType.Static,
+                density: 1
+            }
+        });
+        planeMeshComponent.receiveShadow = true;
+        planeActor.rootComponent.add(planeMeshComponent);
+        planeActor.rootComponent.setLocalRotation(ENGINE.MathHelpers.makeRotationDegrees({ pitch: 90 })); // Rotate the plane to be flat
+        world.addActors(planeActor);
+    }
+    setupCentralFountain() {
+        const world = this.world;
+        // Create an actor for the central fountain
+        this.centralParticleEmitter = new ENGINE.Actor({
+            position: ENGINE.MathHelpers.makeVector({ up: 0 })
+        });
+        // Create a fountain particle emitter using a cone shape
+        const fountainEmitter = new ENGINE.ParticleEmitterComponent({
+            particleCount: 1000,
+            particleSize: 0.3,
+            particleColor: new THREE.Color(0x00aaff),
+            particleSpeed: 10.0,
+            particleLifetime: 3.0,
+            emitterPosition: new THREE.Vector3(0, 0, 0),
+            emitterRotation: new THREE.Euler(0, 0, 0),
+            emitterRate: 100,
+            // Use cone emission for fountain effect
+            emissionDirection: new THREE.Vector3(0, 1, 0),
+            emissionShape: ENGINE.EmissionShape.Cone,
+            emissionAngle: 15 // Narrow cone for a focused fountain
+        });
+        // Add a visual indicator for the emitter source
+        const emitterSphere = new ENGINE.MeshComponent({
+            geometry: new THREE.SphereGeometry(1, 16, 16),
+            material: new THREE.MeshStandardMaterial({
+                color: 0x0088ff,
+                emissive: 0x0044aa,
+                // shininess: 90
+            })
+        });
+        this.centralParticleEmitter.rootComponent.add(emitterSphere);
+        this.centralParticleEmitter.rootComponent.add(fountainEmitter);
+        this.centralParticleEmitter.tag = 'central-fountain';
+        // Cache the emitter
+        if (this.emitterCache) {
+            this.emitterCache.set('central-fountain', fountainEmitter);
+        }
+        else {
+            console.error('Error: emitterCache is not initialized');
+            this.emitterCache = new Map();
+            this.emitterCache.set('central-fountain', fountainEmitter);
+        }
+        world.addActors(this.centralParticleEmitter);
+        // Set up a timer to change the fountain color
+        const timerSystem = world.timerSystem;
+        timerSystem?.setInterval(() => {
+            // Cycle through colors
+            const time = performance.now() / 1000; // Use performance.now() as a simple elapsed time in seconds
+            const r = Math.sin(time * 0.7) * 0.5 + 0.5;
+            const g = Math.sin(time * 0.3) * 0.5 + 0.5;
+            const b = Math.cos(time * 0.5) * 0.5 + 0.5;
+            fountainEmitter.setParticleColor(new THREE.Color(r, g, b));
+        }, 0.1, 'fountain-color-change');
+    }
+    setupParticleShowcase() {
+        // First check if the world exists
+        if (!this.world) {
+            console.error('Cannot setup particle showcase: world is not initialized');
+            return;
+        }
+        // Ensure the emitterShowcase array is initialized
+        if (!this.emitterShowcase) {
+            this.emitterShowcase = [];
+        }
+        try {
+            // Create different particle effect examples around the center
+            // 1. Disc emitter - fire wall
+            this.createShowcaseEmitter(new THREE.Vector3(-20, 0, 0), 'Fire Wall (Disc)', () => {
+                const emitter = new ENGINE.ParticleEmitterComponent({
+                    particleCount: 800,
+                    particleSize: 0.5,
+                    particleColor: new THREE.Color(0xff5500),
+                    particleSpeed: 5,
+                    particleLifetime: 1.2,
+                    emitterRate: 200,
+                    emitterPosition: new THREE.Vector3(0, 0, 0),
+                    emitterRotation: new THREE.Euler(0, 0, 0),
+                    // Emit from a disc, with particles moving upward
+                    emissionDirection: new THREE.Vector3(0, 1, 0),
+                    emissionShape: ENGINE.EmissionShape.Disc,
+                    emissionRadius: 3.0
+                });
+                return emitter;
+            });
+            // 2. Cone emitter - geyser
+            this.createShowcaseEmitter(new THREE.Vector3(-10, 0, 0), 'Geyser (Cone)', () => {
+                const emitter = new ENGINE.ParticleEmitterComponent({
+                    particleCount: 500,
+                    particleSize: 0.4,
+                    particleColor: new THREE.Color(0xaaddff),
+                    particleSpeed: 15,
+                    particleLifetime: 2,
+                    emitterRate: 150,
+                    emitterPosition: new THREE.Vector3(0, 0, 0),
+                    emitterRotation: new THREE.Euler(0, 0, 0),
+                    // Emit in a cone upward
+                    emissionDirection: new THREE.Vector3(0, 1, 0),
+                    emissionShape: ENGINE.EmissionShape.Cone,
+                    emissionAngle: 10 // Narrow for directed jet
+                });
+                return emitter;
+            });
+            // 3. Box emitter - smoke column
+            this.createShowcaseEmitter(new THREE.Vector3(10, 0, 0), 'Smoke (Box)', () => {
+                const emitter = new ENGINE.ParticleEmitterComponent({
+                    particleCount: 600,
+                    particleSize: 0.8,
+                    particleColor: new THREE.Color(0x888888),
+                    particleSpeed: 3,
+                    particleLifetime: 4,
+                    emitterRate: 50,
+                    emitterPosition: new THREE.Vector3(0, 0, 0),
+                    emitterRotation: new THREE.Euler(0, 0, 0),
+                    // Emit from a box with slow upward drift
+                    emissionDirection: new THREE.Vector3(0, 1, 0),
+                    emissionShape: ENGINE.EmissionShape.Box,
+                    emissionDimensions: new THREE.Vector3(2, 0.5, 2)
+                });
+                return emitter;
+            });
+            // 4. Sphere emitter - spark shower
+            this.createShowcaseEmitter(new THREE.Vector3(20, 0, 0), 'Spark Shower (Sphere)', () => {
+                const emitter = new ENGINE.ParticleEmitterComponent({
+                    particleCount: 300,
+                    particleSize: 0.15,
+                    particleColor: new THREE.Color(0xffdd00),
+                    particleSpeed: 8,
+                    particleLifetime: 1.5,
+                    emitterRate: 80,
+                    emitterPosition: new THREE.Vector3(0, 0, 0),
+                    emitterRotation: new THREE.Euler(0, 0, 0),
+                    // Emit in all directions (sphere)
+                    emissionShape: ENGINE.EmissionShape.Sphere
+                });
+                return emitter;
+            });
+        }
+        catch (error) {
+            console.error('Error setting up particle showcase:', error);
+        }
+    }
+    createShowcaseEmitter(position, label, createEmitter) {
+        if (!this.world)
+            return;
+        // Create an actor for this showcase emitter
+        const actor = new ENGINE.Actor({
+            position: position
+        });
+        // Create visual base
+        const baseMesh = new ENGINE.MeshComponent({
+            geometry: new THREE.CylinderGeometry(2, 2, 0.5, 16),
+            material: new THREE.MeshStandardMaterial({
+                color: 0x333333,
+                emissive: 0x222222
+            })
+        });
+        // Create the particle emitter
+        const emitter = createEmitter();
+        // Add components to actor
+        actor.rootComponent.add(baseMesh);
+        actor.rootComponent.add(emitter);
+        actor.tag = label;
+        // Cache the emitter
+        if (this.emitterCache) {
+            this.emitterCache.set(label, emitter);
+        }
+        else {
+            console.error('Error: emitterCache is not initialized');
+            this.emitterCache = new Map();
+            this.emitterCache.set(label, emitter);
+        }
+        // Add text label above the emitter
+        const textMesh = this.createTextLabel(label);
+        textMesh.position.set(0, 5, 0);
+        actor.rootComponent.add(textMesh);
+        // Add to world
+        this.world.addActors(actor);
+        // Track in our array
+        this.emitterShowcase.push(actor);
+    }
+    createTextLabel(text) {
+        try {
+            // Create a simple container for the text
+            const container = new THREE.Object3D();
+            // Create a small plane as a background for the text
+            const planeWidth = Math.max(1, text.length * 0.6);
+            const backgroundMesh = new THREE.Mesh(new THREE.PlaneGeometry(planeWidth, 1), new THREE.MeshBasicMaterial({
+                color: 0x000000,
+                transparent: true,
+                opacity: 0.5,
+                side: THREE.DoubleSide
+            }));
+            // Add the background to the container
+            container.add(backgroundMesh);
+            return container;
+        }
+        catch (error) {
+            console.error('Error creating text label:', error);
+            // Return an empty object if there's an error
+            return new THREE.Object3D();
+        }
+    }
+    cycleShowcaseEmitters() {
+        // This would be much better with proper text rendering but we'll keep it simple
+        // For a real demo, you could use a HTML overlay or a texture-based approach for text
+        // We'll just leave the visual showcase as is
+    }
+    /**
+       * Creates an explosion particle effect at the specified world position
+       * @param position The world position to create the explosion at
+       * @param type The type of explosion to create (0-3)
+       */
+    createExplosionEffect(position, type) {
+        if (!this.world)
+            return;
+        // Default to center position if none provided
+        const explosionPosition = position ?? new THREE.Vector3(0, 10, 0);
+        // Use the specified type or the current one
+        const explosionType = type ?? this.currentExplosionType;
+        // Create a large explosion particle effect at the specified position
+        const explosionActor = new ENGINE.Actor({
+            position: explosionPosition
+        });
+        let explosionEmitter;
+        switch (explosionType) {
+            case 0: // Sphere explosion (classic)
+                explosionEmitter = new ENGINE.ParticleEmitterComponent({
+                    particleCount: 100,
+                    particleSize: 2,
+                    particleColor: new THREE.Color(0xff2200),
+                    particleSpeed: 30.0,
+                    particleLifetime: 1.0,
+                    emitterRate: 1000,
+                    emitterPosition: new THREE.Vector3(0, 0, 0),
+                    emitterRotation: new THREE.Euler(0, 0, 0),
+                    emitContinuously: false, // One-time burst
+                    emissionShape: ENGINE.EmissionShape.Sphere
+                });
+                break;
+            case 1: // Directional blast
+                explosionEmitter = new ENGINE.ParticleEmitterComponent({
+                    particleCount: 80,
+                    particleSize: 1.5,
+                    particleColor: new THREE.Color(0xffaa00),
+                    particleSpeed: 40.0,
+                    particleLifetime: 0.8,
+                    emitterRate: 1000,
+                    emitterPosition: new THREE.Vector3(0, 0, 0),
+                    emitterRotation: new THREE.Euler(0, 0, 0),
+                    emitContinuously: false, // One-time burst
+                    emissionShape: ENGINE.EmissionShape.Cone,
+                    emissionDirection: new THREE.Vector3(0, 1, 0), // Upward blast
+                    emissionAngle: 30 // 30 degree cone
+                });
+                break;
+            case 2: // Ring blast
+                explosionEmitter = new ENGINE.ParticleEmitterComponent({
+                    particleCount: 120,
+                    particleSize: 1.0,
+                    particleColor: new THREE.Color(0x00ffff),
+                    particleSpeed: 25.0,
+                    particleLifetime: 1.2,
+                    emitterRate: 1000,
+                    emitterPosition: new THREE.Vector3(0, 0, 0),
+                    emitterRotation: new THREE.Euler(0, 0, 0),
+                    emitContinuously: false, // One-time burst
+                    emissionShape: ENGINE.EmissionShape.Disc,
+                    emissionDirection: new THREE.Vector3(0, 1, 0), // Horizontal ring
+                    emissionRadius: 2 // Start 2 units from center
+                });
+                break;
+            case 3: // Cube explosion
+                explosionEmitter = new ENGINE.ParticleEmitterComponent({
+                    particleCount: 150,
+                    particleSize: 1.0,
+                    particleColor: new THREE.Color(0xff00ff),
+                    particleSpeed: 20.0,
+                    particleLifetime: 1.5,
+                    emitterRate: 1000,
+                    emitterPosition: new THREE.Vector3(0, 0, 0),
+                    emitterRotation: new THREE.Euler(0, 0, 0),
+                    emitContinuously: false, // One-time burst
+                    emissionShape: ENGINE.EmissionShape.Box,
+                    emissionDimensions: new THREE.Vector3(3, 3, 3) // Explode from a 3x3x3 cube
+                });
+                break;
+            default: // Fallback to sphere
+                explosionEmitter = new ENGINE.ParticleEmitterComponent({
+                    particleCount: 100,
+                    particleSize: 2,
+                    particleColor: new THREE.Color(0xff2200),
+                    particleSpeed: 30.0,
+                    particleLifetime: 1.0,
+                    emitterRate: 1000,
+                    emitterPosition: new THREE.Vector3(0, 0, 0),
+                    emitterRotation: new THREE.Euler(0, 0, 0),
+                    emitContinuously: false, // One-time burst
+                    emissionShape: ENGINE.EmissionShape.Sphere
+                });
+        }
+        explosionActor.rootComponent.add(explosionEmitter);
+        this.world.addActors(explosionActor);
+        // Remove the explosion actor after the particles have died out
+        const timerSystem = this.world.timerSystem;
+        timerSystem?.setTimeout(() => {
+            this.world?.removeActors(explosionActor);
+        }, 1.5, 'remove-explosion');
+    }
+    /**
+       * Cycles to the next explosion type
+       */
+    cycleExplosionType() {
+        // Prevent cycling too quickly
+        const now = performance.now();
+        if (now - this.lastEmitterSwitchTime < 500)
+            return;
+        this.lastEmitterSwitchTime = now;
+        this.currentExplosionType = (this.currentExplosionType + 1) % 4;
+        if (!this.world)
+            return;
+        // Create a small preview explosion at the center
+        const previewPosition = new THREE.Vector3(0, 0, 0);
+        this.createExplosionEffect(previewPosition, this.currentExplosionType);
+        let explosionTypeName = '';
+        switch (this.currentExplosionType) {
+            case 0:
+                explosionTypeName = 'Sphere Explosion';
+                break;
+            case 1:
+                explosionTypeName = 'Directional Blast';
+                break;
+            case 2:
+                explosionTypeName = 'Ring Blast';
+                break;
+            case 3:
+                explosionTypeName = 'Cube Explosion';
+                break;
+        }
+        console.log(`Switched to: ${explosionTypeName}`);
+    }
+    /**
+       * Converts screen coordinates to world coordinates using raycasting
+       * @param screenPosition The screen position in normalized device coordinates (NDC)
+       * @param defaultHeight Optional height to use if no intersection with terrain
+       * @returns The world position corresponding to the screen position
+       */
+    getWorldPositionFromScreen(screenPosition, defaultHeight = 0) {
+        if (!this.world) {
+            return new THREE.Vector3(0, defaultHeight, 0);
+        }
+        // Update the raycaster with the current mouse position and camera
+        const camera = this.world.getActiveCamera();
+        this.raycaster.setFromCamera(screenPosition, camera);
+        // Create a ground plane for raycasting at the default height
+        const groundPlane = new THREE.Plane(new THREE.Vector3(0, 1, 0), -defaultHeight);
+        // Cast ray to the scene and get the first intersection
+        const intersects = this.raycaster.intersectObjects(this.world.scene.children, true);
+        if (intersects.length > 0) {
+            // Return the point of intersection with the first object
+            return intersects[0].point;
+        }
+        else {
+            // If no intersection, ray-cast against the ground plane
+            const targetPoint = new THREE.Vector3();
+            this.raycaster.ray.intersectPlane(groundPlane, targetPoint);
+            return targetPoint;
+        }
+    }
+    setupEmitterControls(folder, path, actor) {
+        console.log(`[VFX-Demo] Setting up emitter controls for ${path}, actor present:`, !!actor);
+        if (!actor) {
+            console.warn(`[VFX-Demo] Actor is null for ${path}`);
+            return;
+        }
+        const emitterId = path === 'central' ? 'central-fountain' : path.split('.')[1];
+        // Ensure emitterCache exists
+        if (!this.emitterCache) {
+            console.error('[VFX-Demo] Error: emitterCache is not initialized');
+            this.emitterCache = new Map();
+            return; // Exit since we don't have emitters to control
+        }
+        const emitterComponent = this.emitterCache.get(emitterId);
+        if (!emitterComponent) {
+            console.error(`[VFX-Demo] Error: No emitter component found for ${emitterId}`);
+            console.log('[VFX-Demo] Available emitters:', Array.from(this.emitterCache.keys()));
+            return;
+        }
+        // Ensure emitterParams exists
+        if (!this.emitterParams) {
+            console.error('[VFX-Demo] Error: emitterParams is not initialized');
+            return; // Exit since we don't have parameters to configure
+        }
+        // Safely access params with defensive checks
+        let params;
+        try {
+            if (path === 'central') {
+                if (!this.emitterParams.central) {
+                    console.error('[VFX-Demo] Error: emitterParams.central is not initialized');
+                    return;
+                }
+                params = this.emitterParams.central;
+            }
+            else {
+                if (!this.emitterParams.showcase) {
+                    console.error('[VFX-Demo] Error: emitterParams.showcase is not initialized');
+                    return;
+                }
+                const emitterName = path.split('.')[1];
+                if (!this.emitterParams.showcase[emitterName]) {
+                    console.error(`[VFX-Demo] Error: emitterParams.showcase["${emitterName}"] is not initialized`);
+                    return;
+                }
+                params = this.emitterParams.showcase[emitterName];
+            }
+        }
+        catch (error) {
+            console.error('[VFX-Demo] Error accessing emitterParams:', error);
+            return;
+        }
+        console.log(`[VFX-Demo] Adding controls for ${path} with params:`, params);
+        // Add color control
+        const colorController = folder.addColor(params, 'particleColor').name('Color');
+        colorController.onChange((color) => {
+            emitterComponent.setParticleColor(new THREE.Color(color.r, color.g, color.b));
+        });
+        // Add size control
+        const sizeController = folder.add(params, 'particleSize', 0.1, 5).name('Size');
+        sizeController.onChange((value) => {
+            emitterComponent.setParticleSize(value);
+        });
+        // Add speed control
+        const speedController = folder.add(params, 'particleSpeed', 1, 50).name('Speed');
+        speedController.onChange((value) => {
+            emitterComponent.setParticleSpeed(value);
+        });
+        // Add lifetime control
+        const lifetimeController = folder.add(params, 'particleLifetime', 0.1, 10).name('Lifetime');
+        lifetimeController.onChange((value) => {
+            emitterComponent.setParticleLifetime(value);
+        });
+        // Add emission rate control
+        const rateController = folder.add(params, 'emitterRate', 10, 500).name('Emission Rate');
+        rateController.onChange((value) => {
+            emitterComponent.setEmissionRate(value);
+        });
+        // Add shape-specific controls
+        if ('emissionAngle' in params) {
+            const angleController = folder.add(params, 'emissionAngle', 1, 90).name('Cone Angle');
+            angleController.onChange((value) => {
+                emitterComponent.setEmissionAngle(value);
+            });
+        }
+        if ('emissionRadius' in params) {
+            const radiusParam = params;
+            const radiusController = folder.add(radiusParam, 'emissionRadius', 0.1, 10).name('Radius');
+            radiusController.onChange((value) => {
+                emitterComponent.setEmissionRadius(value);
+            });
+        }
+        if ('emissionDimensions' in params) {
+            const dimParams = params;
+            const dimensionsFolder = folder.addFolder('Box Dimensions');
+            const xController = dimensionsFolder.add(dimParams.emissionDimensions, 'x', 0.1, 10).name('Width');
+            const yController = dimensionsFolder.add(dimParams.emissionDimensions, 'y', 0.1, 10).name('Height');
+            const zController = dimensionsFolder.add(dimParams.emissionDimensions, 'z', 0.1, 10).name('Depth');
+            const updateDimensions = () => {
+                const dimensions = new THREE.Vector3(dimParams.emissionDimensions.x, dimParams.emissionDimensions.y, dimParams.emissionDimensions.z);
+                emitterComponent.setEmissionDimensions(dimensions);
+            };
+            xController.onChange(updateDimensions);
+            yController.onChange(updateDimensions);
+            zController.onChange(updateDimensions);
+        }
+    }
+    // Add a separate method to clean up the GUI
+    cleanupGUI() {
+        if (this.gui) {
+            this.container.removeChild(this.gui.domElement);
+            this.gui.destroy();
+        }
+    }
+    setupGUI() {
+        try {
+            console.error('Error: emitterParams is not initialized in setupGUI');
+            // Initialize it with defaults to prevent errors
+            this.emitterParams = {
+                central: {
+                    particleColor: { r: 0, g: 0.66, b: 1 },
+                    particleSize: 0.3,
+                    particleSpeed: 10.0,
+                    particleLifetime: 3.0,
+                    emitterRate: 100,
+                    emissionAngle: 15
+                },
+                showcase: {
+                    'Fire Wall (Disc)': {
+                        particleColor: { r: 1, g: 0.33, b: 0 },
+                        particleSize: 0.5,
+                        particleSpeed: 5,
+                        particleLifetime: 1.2,
+                        emitterRate: 200,
+                        emissionRadius: 3.0
+                    },
+                    'Geyser (Cone)': {
+                        particleColor: { r: 0.66, g: 0.86, b: 1 },
+                        particleSize: 0.4,
+                        particleSpeed: 15,
+                        particleLifetime: 2.0,
+                        emitterRate: 150,
+                        emissionAngle: 10
+                    },
+                    'Smoke (Box)': {
+                        particleColor: { r: 0.53, g: 0.53, b: 0.53 },
+                        particleSize: 0.8,
+                        particleSpeed: 3,
+                        particleLifetime: 4.0,
+                        emitterRate: 50,
+                        emissionDimensions: { x: 2, y: 0.5, z: 2 }
+                    },
+                    'Spark Shower (Sphere)': {
+                        particleColor: { r: 1, g: 0.86, b: 0 },
+                        particleSize: 0.15,
+                        particleSpeed: 8,
+                        particleLifetime: 1.5,
+                        emitterRate: 80
+                    }
+                }
+            };
+            // Configure GUI styling
+            this.gui.domElement.style.position = 'absolute';
+            this.gui.domElement.style.top = '10px';
+            this.gui.domElement.style.right = '10px';
+            this.gui.domElement.style.zIndex = '1000'; // Ensure the GUI is on top
+            // Add GUI to DOM if needed (not automatic in some cases)
+            if (!document.body.contains(this.gui.domElement)) {
+                document.body.appendChild(this.gui.domElement);
+            }
+            console.log('[VFX-Demo] Setting up GUI controls');
+            // Create folders for each emitter
+            const centralFolder = this.gui.addFolder('Central Fountain');
+            this.setupEmitterControls(centralFolder, 'central', this.centralParticleEmitter);
+            centralFolder.open();
+            // Ensure showcase entries exist
+            if (!this.emitterParams.showcase) {
+                console.error('Error: emitterParams.showcase is not initialized');
+                return;
+            }
+            // Showcase emitters
+            const showcaseFolder = this.gui.addFolder('Showcase Emitters');
+            for (const emitterName in this.emitterParams.showcase) {
+                const subFolder = showcaseFolder.addFolder(emitterName);
+                // Find the actor with this tag - could be optimized with a Map if needed
+                const actor = this.emitterShowcase.find(actor => actor.tag === emitterName);
+                this.setupEmitterControls(subFolder, `showcase.${emitterName}`, actor ?? null);
+            }
+            showcaseFolder.open();
+            console.log('[VFX-Demo] GUI setup complete');
+        }
+        catch (error) {
+            console.error('Error setting up GUI:', error);
+        }
+    }
+    // Add destroy override to clean up GUI
+    destroy() {
+        this.cleanupGUI();
+        super.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vfx-demo.js","sourceRoot":"","sources":["../../games/vfx-demo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,SAAS,CAAC;AAC/B,OAAO,KAAK,MAAM,MAAM,YAAY,CAAC;AACrC,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAU/B,MAAM,OAAO,OAAQ,SAAQ,MAAM,CAAC,YAAY;IAqC9C,YAAY,SAAsB;QAChC,KAAK,CAAC,SAAS,CAAC,CAAC;QArCX;;;;mBAA8C,IAAI;WAAC;QACnD;;;;;WAAgC;QAChC;;;;;WAA6B;QAC7B;;;;;WAA8B;QAC9B;;;;;WAA2B;QAEnC,6BAA6B;QACrB;;;;;WAqBN;QAEF,mBAAmB;QACX;;;;;WAAa;QAErB,uDAAuD;QAC/C;;;;mBAAe,IAAI,GAAG,EAA2C;WAAC;QAIxE,IAAI,CAAC,GAAG,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,EAAC,SAAS,EAAE,KAAK,EAAC,CAAC,CAAC;QAC3C,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAE3C,kCAAkC;QAClC,IAAI,CAAC,SAAS,GAAG,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;QACvC,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAC1B,IAAI,CAAC,oBAAoB,GAAG,CAAC,CAAC;QAC9B,IAAI,CAAC,qBAAqB,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,EAA2C,CAAC;QAEvE,2BAA2B;QAC3B,IAAI,CAAC,aAAa,GAAG;YACnB,OAAO,EAAE;gBACP,aAAa,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;gBACtC,YAAY,EAAE,GAAG;gBACjB,aAAa,EAAE,IAAI;gBACnB,gBAAgB,EAAE,GAAG;gBACrB,WAAW,EAAE,GAAG;gBAChB,aAAa,EAAE,EAAE;aAClB;YACD,QAAQ,EAAE;gBACR,kBAAkB,EAAE;oBAClB,aAAa,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;oBACtC,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,CAAC;oBAChB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,GAAG;oBAChB,cAAc,EAAE,GAAG;iBACpB;gBACD,eAAe,EAAE;oBACf,aAAa,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;oBACzC,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,EAAE;oBACjB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,GAAG;oBAChB,aAAa,EAAE,EAAE;iBAClB;gBACD,aAAa,EAAE;oBACb,aAAa,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE;oBAC5C,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,CAAC;oBAChB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,EAAE;oBACf,kBAAkB,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE;iBAC3C;gBACD,uBAAuB,EAAE;oBACvB,aAAa,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;oBACtC,YAAY,EAAE,IAAI;oBAClB,aAAa,EAAE,CAAC;oBAChB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,EAAE;iBAChB;aACF;SACF,CAAC;IACJ,CAAC;IAEkB,KAAK,CAAC,QAAQ;QAC/B,MAAM,CAAC,WAAW,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrD,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAEO,YAAY;QAClB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QAEzB,MAAM,IAAI,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC;YAC3B,iBAAiB,EAAE,IAAI,MAAM,CAAC,0BAA0B,CAAC;gBACvD,GAAG,MAAM,CAAC,0BAA0B,CAAC,eAAe;gBACpD,QAAQ,EAAE,EAAE;gBACZ,cAAc,EAAE,GAAG;gBACnB,WAAW,EAAE,GAAG;aACjB,CAAC;YACF,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;YAChE,MAAM,EAAE,IAAI,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC;SACrE,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,MAAM,CAAC,WAAW,CAAC,mBAAmB,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QAE5F,iFAAiF;QACjF,MAAM,kBAAkB,GAAG,IAAI,MAAM,CAAC,wBAAwB,CAAC;YAC7D,aAAa,EAAE,GAAG;YAClB,YAAY,EAAE,GAAG;YACjB,aAAa,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;YACxC,aAAa,EAAE,GAAG;YAClB,gBAAgB,EAAE,GAAG;YACrB,eAAe,EAAE,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC;YAC1D,eAAe,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YACzC,WAAW,EAAE,EAAE;YACf,+CAA+C;YAC/C,iBAAiB,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;YAC9C,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,IAAI;YACxC,aAAa,EAAE,EAAE;SAClB,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAE3C,MAAM,UAAU,GAAG,IAAI,MAAM,CAAC,gBAAgB,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QACxE,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACzB,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAElC,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YAC7B,IAAI,CAAC,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;gBACxB,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;gBACjD,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC1B,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,CAAC;QAEH,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACvC,IAAI,MAAM,KAAK,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;gBACvC,MAAM,YAAY,GAAG,UAAU,CAAC,eAAe,EAAE,CAAC;gBAClD,IAAI,YAAY,EAAE,CAAC;oBACjB,oDAAoD;oBACpD,MAAM,aAAa,GAAG,YAAY,CAAC,gBAAgB,EAAE,CAAC;oBAEtD,4CAA4C;oBAC5C,MAAM,aAAa,GAAG,IAAI,CAAC,0BAA0B,CAAC,aAAa,CAAC,CAAC;oBAErE,4CAA4C;oBAC5C,IAAI,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC;oBAE1C,OAAO,IAAI,CAAC,CAAC,qBAAqB;gBACpC,CAAC;YACH,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,iBAAiB;QACvB,iCAAiC;QACjC,IAAI,CAAC,aAAa,GAAG;YACnB,OAAO,EAAE;gBACP,aAAa,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;gBACtC,YAAY,EAAE,GAAG;gBACjB,aAAa,EAAE,IAAI;gBACnB,gBAAgB,EAAE,GAAG;gBACrB,WAAW,EAAE,GAAG;gBAChB,aAAa,EAAE,EAAE;aAClB;YACD,QAAQ,EAAE;gBACR,kBAAkB,EAAE;oBAClB,aAAa,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;oBACtC,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,CAAC;oBAChB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,GAAG;oBAChB,cAAc,EAAE,GAAG;iBACpB;gBACD,eAAe,EAAE;oBACf,aAAa,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;oBACzC,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,EAAE;oBACjB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,GAAG;oBAChB,aAAa,EAAE,EAAE;iBAClB;gBACD,aAAa,EAAE;oBACb,aAAa,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE;oBAC5C,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,CAAC;oBAChB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,EAAE;oBACf,kBAAkB,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE;iBAC3C;gBACD,uBAAuB,EAAE;oBACvB,aAAa,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;oBACtC,YAAY,EAAE,IAAI;oBAClB,aAAa,EAAE,CAAC;oBAChB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,EAAE;iBAChB;aACF;SACF,CAAC;QAEF,gBAAgB;QAChB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE9B,4CAA4C;QAC5C,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAE5B,oDAAoD;QACpD,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAE7B,iDAAiD;QACjD,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC;QAC3C,IAAI,WAAW,EAAE,CAAC;YAChB,WAAW,CAAC,WAAW,CAAC,GAAG,EAAE;gBAC3B,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,CAAC,EAAE,EAAE,EAAE,gBAAgB,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IAEO,YAAY,CAAC,KAAmB;QACtC,8BAA8B;QAC9B,MAAM,UAAU,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;QAC9F,MAAM,UAAU,GAAG,GAAG,CAAC;QACvB,MAAM,UAAU,GAAG,GAAG,CAAC;QACvB,MAAM,aAAa,GAAG,IAAI,KAAK,CAAC,aAAa,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QACtE,MAAM,aAAa,GAAG,IAAI,KAAK,CAAC,oBAAoB,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,gCAAgC;QAEnI,MAAM,kBAAkB,GAAG,IAAI,MAAM,CAAC,aAAa,CAAC;YAClD,QAAQ,EAAE,aAAa;YACvB,QAAQ,EAAE,aAAa;YACvB,cAAc,EAAE;gBACd,OAAO,EAAE,IAAI;gBACb,UAAU,EAAE,MAAM,CAAC,iBAAiB,CAAC,MAAM;gBAC3C,OAAO,EAAE,CAAC;aACX;SACF,CAAC,CAAC;QACH,kBAAkB,CAAC,aAAa,GAAG,IAAI,CAAC;QACxC,UAAU,CAAC,aAAa,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QACjD,UAAU,CAAC,aAAa,CAAC,gBAAgB,CAAC,MAAM,CAAC,WAAW,CAAC,mBAAmB,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,8BAA8B;QAChI,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IAC9B,CAAC;IAEO,oBAAoB;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAM,CAAC;QAE1B,2CAA2C;QAC3C,IAAI,CAAC,sBAAsB,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC;YAC7C,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;SACnD,CAAC,CAAC;QAEH,wDAAwD;QACxD,MAAM,eAAe,GAAG,IAAI,MAAM,CAAC,wBAAwB,CAAC;YAC1D,aAAa,EAAE,IAAI;YACnB,YAAY,EAAE,GAAG;YACjB,aAAa,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;YACxC,aAAa,EAAE,IAAI;YACnB,gBAAgB,EAAE,GAAG;YACrB,eAAe,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YAC3C,eAAe,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YACzC,WAAW,EAAE,GAAG;YAChB,wCAAwC;YACxC,iBAAiB,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YAC7C,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,IAAI;YACxC,aAAa,EAAE,EAAE,CAAC,qCAAqC;SACxD,CAAC,CAAC;QAEH,gDAAgD;QAChD,MAAM,aAAa,GAAG,IAAI,MAAM,CAAC,aAAa,CAAC;YAC7C,QAAQ,EAAE,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;YAC7C,QAAQ,EAAE,IAAI,KAAK,CAAC,oBAAoB,CAAC;gBACvC,KAAK,EAAE,QAAQ;gBACf,QAAQ,EAAE,QAAQ;gBAClB,gBAAgB;aACjB,CAAC;SACH,CAAC,CAAC;QAEH,IAAI,CAAC,sBAAsB,CAAC,aAAa,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAC7D,IAAI,CAAC,sBAAsB,CAAC,aAAa,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAC/D,IAAI,CAAC,sBAAsB,CAAC,GAAG,GAAG,kBAAkB,CAAC;QAErD,oBAAoB;QACpB,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,kBAAkB,EAAE,eAAe,CAAC,CAAC;QAC7D,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC;YACxD,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,EAA2C,CAAC;YACvE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,kBAAkB,EAAE,eAAe,CAAC,CAAC;QAC7D,CAAC;QAED,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAE7C,8CAA8C;QAC9C,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;QACtC,WAAW,EAAE,WAAW,CAAC,GAAG,EAAE;YAC5B,uBAAuB;YACvB,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,4DAA4D;YACnG,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC;YAC3C,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC;YAC3C,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC;YAE3C,eAAe,CAAC,gBAAgB,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC7D,CAAC,EAAE,GAAG,EAAE,uBAAuB,CAAC,CAAC;IACnC,CAAC;IAEO,qBAAqB;QAC3B,kCAAkC;QAClC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAChB,OAAO,CAAC,KAAK,CAAC,0DAA0D,CAAC,CAAC;YAC1E,OAAO;QACT,CAAC;QAED,kDAAkD;QAClD,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;YAC1B,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC;YACH,8DAA8D;YAE9D,8BAA8B;YAC9B,IAAI,CAAC,qBAAqB,CACxB,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5B,kBAAkB,EAClB,GAAG,EAAE;gBACH,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC,wBAAwB,CAAC;oBAClD,aAAa,EAAE,GAAG;oBAClB,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;oBACxC,aAAa,EAAE,CAAC;oBAChB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,GAAG;oBAChB,eAAe,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC3C,eAAe,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBACzC,iDAAiD;oBACjD,iBAAiB,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC7C,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,IAAI;oBACxC,cAAc,EAAE,GAAG;iBACpB,CAAC,CAAC;gBACH,OAAO,OAAO,CAAC;YACjB,CAAC,CACF,CAAC;YAEF,2BAA2B;YAC3B,IAAI,CAAC,qBAAqB,CACxB,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5B,eAAe,EACf,GAAG,EAAE;gBACH,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC,wBAAwB,CAAC;oBAClD,aAAa,EAAE,GAAG;oBAClB,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;oBACxC,aAAa,EAAE,EAAE;oBACjB,gBAAgB,EAAE,CAAC;oBACnB,WAAW,EAAE,GAAG;oBAChB,eAAe,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC3C,eAAe,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBACzC,wBAAwB;oBACxB,iBAAiB,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC7C,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,IAAI;oBACxC,aAAa,EAAE,EAAE,CAAC,0BAA0B;iBAC7C,CAAC,CAAC;gBACH,OAAO,OAAO,CAAC;YACjB,CAAC,CACF,CAAC;YAEF,gCAAgC;YAChC,IAAI,CAAC,qBAAqB,CACxB,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,EAC3B,aAAa,EACb,GAAG,EAAE;gBACH,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC,wBAAwB,CAAC;oBAClD,aAAa,EAAE,GAAG;oBAClB,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;oBACxC,aAAa,EAAE,CAAC;oBAChB,gBAAgB,EAAE,CAAC;oBACnB,WAAW,EAAE,EAAE;oBACf,eAAe,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC3C,eAAe,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBACzC,yCAAyC;oBACzC,iBAAiB,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC7C,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,GAAG;oBACvC,kBAAkB,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;iBACjD,CAAC,CAAC;gBACH,OAAO,OAAO,CAAC;YACjB,CAAC,CACF,CAAC;YAEF,mCAAmC;YACnC,IAAI,CAAC,qBAAqB,CACxB,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,EAC3B,uBAAuB,EACvB,GAAG,EAAE;gBACH,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC,wBAAwB,CAAC;oBAClD,aAAa,EAAE,GAAG;oBAClB,YAAY,EAAE,IAAI;oBAClB,aAAa,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;oBACxC,aAAa,EAAE,CAAC;oBAChB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,EAAE;oBACf,eAAe,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC3C,eAAe,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBACzC,kCAAkC;oBAClC,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,MAAM;iBAC3C,CAAC,CAAC;gBACH,OAAO,OAAO,CAAC;YACjB,CAAC,CACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,qCAAqC,EAAE,KAAK,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IAEO,qBAAqB,CAAC,QAAuB,EAAE,KAAa,EAAE,aAAoD;QACxH,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,OAAO;QAExB,4CAA4C;QAC5C,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC;YAC7B,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;QAEH,qBAAqB;QACrB,MAAM,QAAQ,GAAG,IAAI,MAAM,CAAC,aAAa,CAAC;YACxC,QAAQ,EAAE,IAAI,KAAK,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC;YACnD,QAAQ,EAAE,IAAI,KAAK,CAAC,oBAAoB,CAAC;gBACvC,KAAK,EAAE,QAAQ;gBACf,QAAQ,EAAE,QAAQ;aACnB,CAAC;SACH,CAAC,CAAC;QAEH,8BAA8B;QAC9B,MAAM,OAAO,GAAG,aAAa,EAAE,CAAC;QAEhC,0BAA0B;QAC1B,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAClC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACjC,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC;QAElB,oBAAoB;QACpB,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACxC,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC;YACxD,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,EAA2C,CAAC;YACvE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACxC,CAAC;QAED,mCAAmC;QACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;QAC7C,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAC/B,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAElC,eAAe;QACf,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAE5B,qBAAqB;QACrB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;IAEO,eAAe,CAAC,IAAY;QAClC,IAAI,CAAC;YACH,yCAAyC;YACzC,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YAEvC,oDAAoD;YACpD,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC;YAClD,MAAM,cAAc,GAAG,IAAI,KAAK,CAAC,IAAI,CACnC,IAAI,KAAK,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC,CAAC,EACtC,IAAI,KAAK,CAAC,iBAAiB,CAAC;gBAC1B,KAAK,EAAE,QAAQ;gBACf,WAAW,EAAE,IAAI;gBACjB,OAAO,EAAE,GAAG;gBACZ,IAAI,EAAE,KAAK,CAAC,UAAU;aACvB,CAAC,CACH,CAAC;YAEF,sCAAsC;YACtC,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;YAE9B,OAAO,SAAS,CAAC;QACnB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,4BAA4B,EAAE,KAAK,CAAC,CAAC;YACnD,6CAA6C;YAC7C,OAAO,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC;IAEO,qBAAqB;QAC3B,gFAAgF;QAChF,qFAAqF;QAErF,6CAA6C;IAC/C,CAAC;IAED;;;;SAIK;IACE,qBAAqB,CAAC,QAAwB,EAAE,IAAa;QAClE,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,OAAO;QAExB,8CAA8C;QAC9C,MAAM,iBAAiB,GAAG,QAAQ,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;QAElE,4CAA4C;QAC5C,MAAM,aAAa,GAAG,IAAI,IAAI,IAAI,CAAC,oBAAoB,CAAC;QAExD,qEAAqE;QACrE,MAAM,cAAc,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC;YACtC,QAAQ,EAAE,iBAAiB;SAC5B,CAAC,CAAC;QAEH,IAAI,gBAAiD,CAAC;QAEtD,QAAQ,aAAa,EAAE,CAAC;YACtB,KAAK,CAAC,EAAE,6BAA6B;gBACnC,gBAAgB,GAAG,IAAI,MAAM,CAAC,wBAAwB,CAAC;oBACrD,aAAa,EAAE,GAAG;oBAClB,YAAY,EAAE,CAAC;oBACf,aAAa,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;oBACxC,aAAa,EAAE,IAAI;oBACnB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,IAAI;oBACjB,eAAe,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC3C,eAAe,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBACzC,gBAAgB,EAAE,KAAK,EAAE,iBAAiB;oBAC1C,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,MAAM;iBAC3C,CAAC,CAAC;gBACH,MAAM;YAER,KAAK,CAAC,EAAE,oBAAoB;gBAC1B,gBAAgB,GAAG,IAAI,MAAM,CAAC,wBAAwB,CAAC;oBACrD,aAAa,EAAE,EAAE;oBACjB,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;oBACxC,aAAa,EAAE,IAAI;oBACnB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,IAAI;oBACjB,eAAe,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC3C,eAAe,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBACzC,gBAAgB,EAAE,KAAK,EAAE,iBAAiB;oBAC1C,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,IAAI;oBACxC,iBAAiB,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,eAAe;oBAC9D,aAAa,EAAE,EAAE,CAAC,iBAAiB;iBACpC,CAAC,CAAC;gBACH,MAAM;YAER,KAAK,CAAC,EAAE,aAAa;gBACnB,gBAAgB,GAAG,IAAI,MAAM,CAAC,wBAAwB,CAAC;oBACrD,aAAa,EAAE,GAAG;oBAClB,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;oBACxC,aAAa,EAAE,IAAI;oBACnB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,IAAI;oBACjB,eAAe,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC3C,eAAe,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBACzC,gBAAgB,EAAE,KAAK,EAAE,iBAAiB;oBAC1C,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,IAAI;oBACxC,iBAAiB,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,kBAAkB;oBACjE,cAAc,EAAE,CAAC,CAAC,4BAA4B;iBAC/C,CAAC,CAAC;gBACH,MAAM;YAER,KAAK,CAAC,EAAE,iBAAiB;gBACvB,gBAAgB,GAAG,IAAI,MAAM,CAAC,wBAAwB,CAAC;oBACrD,aAAa,EAAE,GAAG;oBAClB,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;oBACxC,aAAa,EAAE,IAAI;oBACnB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,IAAI;oBACjB,eAAe,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC3C,eAAe,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBACzC,gBAAgB,EAAE,KAAK,EAAE,iBAAiB;oBAC1C,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,GAAG;oBACvC,kBAAkB,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,4BAA4B;iBAC5E,CAAC,CAAC;gBACH,MAAM;YAER,SAAS,qBAAqB;gBAC5B,gBAAgB,GAAG,IAAI,MAAM,CAAC,wBAAwB,CAAC;oBACrD,aAAa,EAAE,GAAG;oBAClB,YAAY,EAAE,CAAC;oBACf,aAAa,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;oBACxC,aAAa,EAAE,IAAI;oBACnB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,IAAI;oBACjB,eAAe,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBAC3C,eAAe,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;oBACzC,gBAAgB,EAAE,KAAK,EAAE,iBAAiB;oBAC1C,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,MAAM;iBAC3C,CAAC,CAAC;QACP,CAAC;QAED,cAAc,CAAC,aAAa,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QACnD,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;QAErC,+DAA+D;QAC/D,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC;QAC3C,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE;YAC3B,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,cAAc,CAAC,CAAC;QAC3C,CAAC,EAAE,GAAG,EAAE,kBAAkB,CAAC,CAAC;IAC9B,CAAC;IAED;;SAEK;IACE,kBAAkB;QACvB,8BAA8B;QAC9B,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAC9B,IAAI,GAAG,GAAG,IAAI,CAAC,qBAAqB,GAAG,GAAG;YAAE,OAAO;QAEnD,IAAI,CAAC,qBAAqB,GAAG,GAAG,CAAC;QACjC,IAAI,CAAC,oBAAoB,GAAG,CAAC,IAAI,CAAC,oBAAoB,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QAEhE,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,OAAO;QAExB,iDAAiD;QACjD,MAAM,eAAe,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC,qBAAqB,CAAC,eAAe,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAEvE,IAAI,iBAAiB,GAAG,EAAE,CAAC;QAC3B,QAAQ,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAClC,KAAK,CAAC;gBAAE,iBAAiB,GAAG,kBAAkB,CAAC;gBAAC,MAAM;YACtD,KAAK,CAAC;gBAAE,iBAAiB,GAAG,mBAAmB,CAAC;gBAAC,MAAM;YACvD,KAAK,CAAC;gBAAE,iBAAiB,GAAG,YAAY,CAAC;gBAAC,MAAM;YAChD,KAAK,CAAC;gBAAE,iBAAiB,GAAG,gBAAgB,CAAC;gBAAC,MAAM;QACtD,CAAC;QAED,OAAO,CAAC,GAAG,CAAC,gBAAgB,iBAAiB,EAAE,CAAC,CAAC;IACnD,CAAC;IAED;;;;;SAKK;IACE,0BAA0B,CAAC,cAA6B,EAAE,gBAAwB,CAAC;QACxF,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAChB,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC;QAChD,CAAC;QAED,kEAAkE;QAClE,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,EAAG,CAAC;QAC7C,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;QAErD,6DAA6D;QAC7D,MAAM,WAAW,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC;QAEhF,uDAAuD;QACvD,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAEpF,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1B,yDAAyD;YACzD,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAC7B,CAAC;aAAM,CAAC;YACN,wDAAwD;YACxD,MAAM,WAAW,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YACxC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;YAC5D,OAAO,WAAW,CAAC;QACrB,CAAC;IACH,CAAC;IAEO,oBAAoB,CAAC,MAAe,EAAE,IAAY,EAAE,KAA0B;QACpF,OAAO,CAAC,GAAG,CAAC,8CAA8C,IAAI,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;QAE3F,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,gCAAgC,IAAI,EAAE,CAAC,CAAC;YACrD,OAAO;QACT,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAE/E,6BAA6B;QAC7B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,OAAO,CAAC,KAAK,CAAC,mDAAmD,CAAC,CAAC;YACnE,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,EAA2C,CAAC;YACvE,OAAO,CAAC,+CAA+C;QACzD,CAAC;QAED,MAAM,gBAAgB,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAE1D,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,OAAO,CAAC,KAAK,CAAC,oDAAoD,SAAS,EAAE,CAAC,CAAC;YAC/E,OAAO,CAAC,GAAG,CAAC,gCAAgC,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;YACpF,OAAO;QACT,CAAC;QAED,8BAA8B;QAC9B,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,OAAO,CAAC,KAAK,CAAC,oDAAoD,CAAC,CAAC;YACpE,OAAO,CAAC,mDAAmD;QAC7D,CAAC;QAED,6CAA6C;QAC7C,IAAI,MAAW,CAAC;QAChB,IAAI,CAAC;YACH,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACvB,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;oBAChC,OAAO,CAAC,KAAK,CAAC,4DAA4D,CAAC,CAAC;oBAC5E,OAAO;gBACT,CAAC;gBACD,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;YACtC,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;oBACjC,OAAO,CAAC,KAAK,CAAC,6DAA6D,CAAC,CAAC;oBAC7E,OAAO;gBACT,CAAC;gBACD,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBACvC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;oBAC9C,OAAO,CAAC,KAAK,CAAC,6CAA6C,WAAW,uBAAuB,CAAC,CAAC;oBAC/F,OAAO;gBACT,CAAC;gBACD,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;YACpD,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,2CAA2C,EAAE,KAAK,CAAC,CAAC;YAClE,OAAO;QACT,CAAC;QAED,OAAO,CAAC,GAAG,CAAC,kCAAkC,IAAI,eAAe,EAAE,MAAM,CAAC,CAAC;QAE3E,oBAAoB;QACpB,MAAM,eAAe,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC/E,eAAe,CAAC,QAAQ,CAAC,CAAC,KAAwC,EAAE,EAAE;YACpE,gBAAgB,CAAC,gBAAgB,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAChF,CAAC,CAAC,CAAC;QAEH,mBAAmB;QACnB,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC/E,cAAc,CAAC,QAAQ,CAAC,CAAC,KAAa,EAAE,EAAE;YACxC,gBAAgB,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;QAEH,oBAAoB;QACpB,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACjF,eAAe,CAAC,QAAQ,CAAC,CAAC,KAAa,EAAE,EAAE;YACzC,gBAAgB,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,uBAAuB;QACvB,MAAM,kBAAkB,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC5F,kBAAkB,CAAC,QAAQ,CAAC,CAAC,KAAa,EAAE,EAAE;YAC5C,gBAAgB,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;QAEH,4BAA4B;QAC5B,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACxF,cAAc,CAAC,QAAQ,CAAC,CAAC,KAAa,EAAE,EAAE;YACxC,gBAAgB,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;QAEH,8BAA8B;QAC9B,IAAI,eAAe,IAAI,MAAM,EAAE,CAAC;YAC9B,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACtF,eAAe,CAAC,QAAQ,CAAC,CAAC,KAAa,EAAE,EAAE;gBACzC,gBAAgB,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;YAC3C,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,gBAAgB,IAAI,MAAM,EAAE,CAAC;YAC/B,MAAM,WAAW,GAAG,MAAoC,CAAC;YACzD,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,gBAAgB,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC3F,gBAAgB,CAAC,QAAQ,CAAC,CAAC,KAAa,EAAE,EAAE;gBAC1C,gBAAgB,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;YAC5C,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,oBAAoB,IAAI,MAAM,EAAE,CAAC;YACnC,MAAM,SAAS,GAAG,MAAqE,CAAC;YACxF,MAAM,gBAAgB,GAAG,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;YAE5D,MAAM,WAAW,GAAG,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,kBAAkB,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACnG,MAAM,WAAW,GAAG,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,kBAAkB,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACpG,MAAM,WAAW,GAAG,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,kBAAkB,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAEnG,MAAM,gBAAgB,GAAG,GAAG,EAAE;gBAC5B,MAAM,UAAU,GAAG,IAAI,KAAK,CAAC,OAAO,CAClC,SAAS,CAAC,kBAAkB,CAAC,CAAC,EAC9B,SAAS,CAAC,kBAAkB,CAAC,CAAC,EAC9B,SAAS,CAAC,kBAAkB,CAAC,CAAC,CAC/B,CAAC;gBACF,gBAAgB,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;YACrD,CAAC,CAAC;YAEF,WAAW,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC;YACvC,WAAW,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC;YACvC,WAAW,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IAED,4CAA4C;IACpC,UAAU;QAChB,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YAChD,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACrB,CAAC;IACH,CAAC;IAEO,QAAQ;QACd,IAAI,CAAC;YACH,OAAO,CAAC,KAAK,CAAC,qDAAqD,CAAC,CAAC;YACrE,gDAAgD;YAChD,IAAI,CAAC,aAAa,GAAG;gBACnB,OAAO,EAAE;oBACP,aAAa,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;oBACtC,YAAY,EAAE,GAAG;oBACjB,aAAa,EAAE,IAAI;oBACnB,gBAAgB,EAAE,GAAG;oBACrB,WAAW,EAAE,GAAG;oBAChB,aAAa,EAAE,EAAE;iBAClB;gBACD,QAAQ,EAAE;oBACR,kBAAkB,EAAE;wBAClB,aAAa,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;wBACtC,YAAY,EAAE,GAAG;wBACjB,aAAa,EAAE,CAAC;wBAChB,gBAAgB,EAAE,GAAG;wBACrB,WAAW,EAAE,GAAG;wBAChB,cAAc,EAAE,GAAG;qBACpB;oBACD,eAAe,EAAE;wBACf,aAAa,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;wBACzC,YAAY,EAAE,GAAG;wBACjB,aAAa,EAAE,EAAE;wBACjB,gBAAgB,EAAE,GAAG;wBACrB,WAAW,EAAE,GAAG;wBAChB,aAAa,EAAE,EAAE;qBAClB;oBACD,aAAa,EAAE;wBACb,aAAa,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE;wBAC5C,YAAY,EAAE,GAAG;wBACjB,aAAa,EAAE,CAAC;wBAChB,gBAAgB,EAAE,GAAG;wBACrB,WAAW,EAAE,EAAE;wBACf,kBAAkB,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE;qBAC3C;oBACD,uBAAuB,EAAE;wBACvB,aAAa,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;wBACtC,YAAY,EAAE,IAAI;wBAClB,aAAa,EAAE,CAAC;wBAChB,gBAAgB,EAAE,GAAG;wBACrB,WAAW,EAAE,EAAE;qBAChB;iBACF;aACF,CAAC;YAEF,wBAAwB;YACxB,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,QAAQ,GAAG,UAAU,CAAC;YAChD,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,GAAG,MAAM,CAAC;YACvC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC;YACzC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,2BAA2B;YAEtE,yDAAyD;YACzD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBACjD,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YACjD,CAAC;YAED,OAAO,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAAC;YAElD,kCAAkC;YAClC,MAAM,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC;YAC7D,IAAI,CAAC,oBAAoB,CAAC,aAAa,EAAE,SAAS,EAAE,IAAI,CAAC,sBAAsB,CAAC,CAAC;YACjF,aAAa,CAAC,IAAI,EAAE,CAAC;YAErB,gCAAgC;YAChC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;gBACjC,OAAO,CAAC,KAAK,CAAC,kDAAkD,CAAC,CAAC;gBAClE,OAAO;YACT,CAAC;YAED,oBAAoB;YACpB,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC;YAE/D,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;gBACtD,MAAM,SAAS,GAAG,cAAc,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;gBACxD,yEAAyE;gBACzE,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,KAAK,WAAW,CAAC,CAAC;gBAC5E,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,YAAY,WAAW,EAAE,EAAE,KAAK,IAAI,IAAI,CAAC,CAAC;YACjF,CAAC;YAED,cAAc,CAAC,IAAI,EAAE,CAAC;YAEtB,OAAO,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;QAC/C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAED,uCAAuC;IACvB,OAAO;QACrB,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,KAAK,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC;CACF"}