/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1");

/**** 
* Classes
****/ 
var CosmicBeam = Container.expand(function () {
	var self = Container.call(this);
	// Create beam using luminaDust asset as stretched light beam
	var beamGraphics = self.attachAsset('luminaDust', {
		anchorX: 0.0,
		anchorY: 0.5
	});
	// Choose random traversal direction (horizontal, vertical, or diagonal)
	var traversalType = Math.floor(Math.random() * 3);
	var startX, startY, endX, endY;
	switch (traversalType) {
		case 0:
			// Horizontal traversal
			startX = -300;
			startY = Math.random() * 2732;
			endX = 2348;
			endY = startY + (Math.random() - 0.5) * 200; // Slight curve
			break;
		case 1:
			// Vertical traversal
			startX = Math.random() * 2048;
			startY = -300;
			endX = startX + (Math.random() - 0.5) * 200;
			endY = 3032;
			break;
		case 2:
			// Diagonal traversal
			if (Math.random() < 0.5) {
				// Top-left to bottom-right
				startX = -300;
				startY = -300;
				endX = 2348;
				endY = 3032;
			} else {
				// Top-right to bottom-left
				startX = 2348;
				startY = -300;
				endX = -300;
				endY = 3032;
			}
			break;
	}
	// Calculate beam properties
	var deltaX = endX - startX;
	var deltaY = endY - startY;
	var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
	var angle = Math.atan2(deltaY, deltaX);
	// Configure beam appearance
	beamGraphics.scaleX = distance / 20; // Stretch to cover full traversal
	beamGraphics.scaleY = 0.05 + Math.random() * 0.05; // Very thin beam with soft edges
	beamGraphics.rotation = angle;
	beamGraphics.alpha = 0.0; // Start invisible
	// Very faint ethereal colors for subtle appearance
	var beamColors = [0xffffff,
	// Pure white
	0xe6f0ff,
	// Cool blue-white
	0xfff4e6,
	// Warm golden-white
	0xf0e6ff,
	// Purple-white
	0xe6fff0 // Green-white
	];
	var colorIndex = Math.floor(Math.random() * beamColors.length);
	beamGraphics.tint = beamColors[colorIndex];
	// Beam lifecycle properties
	self.lifeSpan = 180 + Math.random() * 240; // 3-7 seconds at 60fps
	self.age = 0;
	self.materializationDuration = 30 + Math.random() * 30; // 0.5-1 second materialization
	self.fadeDuration = 60 + Math.random() * 60; // 1-2 second fade out
	self.traversalSpeed = 0.8 + Math.random() * 0.4; // Slow traversal speed
	// Position at start
	self.x = startX;
	self.y = startY;
	// Store traversal target
	self.targetX = endX;
	self.targetY = endY;
	self.traversalProgress = 0.0;
	// Slow materialization phase
	tween(beamGraphics, {
		alpha: 0.03 + Math.random() * 0.05 // Very low opacity maximum
	}, {
		duration: self.materializationDuration * 16.67,
		// Convert to milliseconds
		easing: tween.easeOut
	});
	self.update = function () {
		self.age++;
		// Slow traversal across screen
		if (self.age > self.materializationDuration) {
			self.traversalProgress += self.traversalSpeed / distance;
			self.x = startX + (endX - startX) * self.traversalProgress;
			self.y = startY + (endY - startY) * self.traversalProgress;
		}
		// Begin fade out near end of lifespan
		if (self.age > self.lifeSpan - self.fadeDuration) {
			var fadeProgress = (self.lifeSpan - self.age) / self.fadeDuration;
			beamGraphics.alpha *= fadeProgress;
		}
		// Subtle flickering during visibility for ethereal effect
		if (beamGraphics.alpha > 0.01) {
			var flicker = 0.85 + Math.sin(self.age * 0.2) * 0.15;
			beamGraphics.alpha *= flicker;
		}
		// Remove when expired or off-screen
		if (self.age >= self.lifeSpan || self.traversalProgress >= 1.0) {
			self.destroy();
			for (var i = cosmicBeams.length - 1; i >= 0; i--) {
				if (cosmicBeams[i] === self) {
					cosmicBeams.splice(i, 1);
					break;
				}
			}
		}
	};
	return self;
});
var CosmicParticle = Container.expand(function (x, y) {
	var self = Container.call(this);
	var particleGraphics = self.attachAsset('luminaDust', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = x;
	self.y = y;
	// Particle properties for curving movement
	self.curvePhase = Math.random() * Math.PI * 2;
	self.curveSpeed = 0.005 + Math.random() * 0.003; // Very slow curving motion
	self.curveAmplitude = 50 + Math.random() * 100; // Gentle curve amplitude
	self.driftX = (Math.random() - 0.5) * 0.3; // Slow horizontal drift
	self.driftY = (Math.random() - 0.5) * 0.2; // Slow vertical drift
	self.lifeSpan = 1800 + Math.random() * 1200; // 30-50 seconds at 60fps
	self.age = 0;
	self.fadeInDuration = 300 + Math.random() * 300; // 5-10 seconds fade in
	self.fadeOutStart = self.lifeSpan - 600; // Start fading out 10 seconds before end
	// Initialize with very low opacity
	particleGraphics.alpha = 0.0;
	particleGraphics.scaleX = 0.3 + Math.random() * 0.4; // Small, soft particles
	particleGraphics.scaleY = particleGraphics.scaleX;
	// Match nebula palette or slight contrast
	var particleColors = [0xffd700,
	// Golden (slight contrast to purple nebula)
	0xe6e6ff,
	// Soft blue-white (matches cool nebula tones)
	0xddd4ff,
	// Purple-white (matches nebula palette)
	0xffd4e6,
	// Warm pink-white (slight contrast)
	0xb19cd9 // Violet (matches evolved nebula)
	];
	var colorIndex = Math.min(currentColorPhase, particleColors.length - 1);
	particleGraphics.tint = particleColors[colorIndex];
	self.update = function () {
		self.age++;
		// Gentle curving movement along curved paths
		var curveOffset = Math.sin(self.age * self.curveSpeed + self.curvePhase) * self.curveAmplitude;
		self.x += self.driftX + Math.cos(self.age * self.curveSpeed * 0.7) * 0.1;
		self.y += self.driftY + Math.sin(self.age * self.curveSpeed * 0.5) * 0.1;
		// Add gentle curve displacement
		var baseX = self.x + curveOffset * 0.01;
		var baseY = self.y + Math.cos(self.age * self.curveSpeed * 0.8 + self.curvePhase) * self.curveAmplitude * 0.008;
		self.x = baseX;
		self.y = baseY;
		// Fade in/out lifecycle - no abrupt appearance/disappearance
		if (self.age < self.fadeInDuration) {
			// Gradual fade in
			var fadeInProgress = self.age / self.fadeInDuration;
			particleGraphics.alpha = (0.05 + Math.random() * 0.08) * fadeInProgress; // Very low opacity
		} else if (self.age > self.fadeOutStart) {
			// Gradual fade out
			var fadeOutProgress = (self.lifeSpan - self.age) / (self.lifeSpan - self.fadeOutStart);
			particleGraphics.alpha = (0.05 + Math.random() * 0.08) * fadeOutProgress;
		} else {
			// Subtle opacity fluctuation during main life
			var opacityFluctuation = 0.05 + Math.sin(self.age * 0.02) * 0.03;
			particleGraphics.alpha = Math.max(0.02, Math.min(0.13, opacityFluctuation));
		}
		// Gentle scale breathing
		var scaleBreathing = 1.0 + Math.sin(self.age * 0.008) * 0.1;
		particleGraphics.scaleX = (0.3 + Math.random() * 0.4) * scaleBreathing;
		particleGraphics.scaleY = particleGraphics.scaleX;
		// Soft rotation
		particleGraphics.rotation += 0.001;
		// Remove when lifespan is complete
		if (self.age >= self.lifeSpan) {
			self.destroy();
			for (var i = cosmicParticles.length - 1; i >= 0; i--) {
				if (cosmicParticles[i] === self) {
					cosmicParticles.splice(i, 1);
					break;
				}
			}
		}
	};
	return self;
});
var CosmicRay = Container.expand(function (startX, startY, endX, endY) {
	var self = Container.call(this);
	// Create ray using luminaDust asset as a stretched beam
	var rayGraphics = self.attachAsset('luminaDust', {
		anchorX: 0.0,
		anchorY: 0.5
	});
	self.x = startX;
	self.y = startY;
	// Calculate ray properties
	var deltaX = endX - startX;
	var deltaY = endY - startY;
	var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
	var angle = Math.atan2(deltaY, deltaX);
	// Configure ray appearance
	rayGraphics.scaleX = distance / 20; // Stretch to cover distance
	rayGraphics.scaleY = 0.1 + Math.random() * 0.1; // Very thin beam
	rayGraphics.rotation = angle;
	rayGraphics.alpha = 0.0; // Start invisible
	// Very faint cosmic colors
	var rayColors = [0xffffff,
	// Pure white
	0xe6e6ff,
	// Cool blue-white
	0xffd4e6,
	// Warm pink-white
	0xddd4ff,
	// Purple-white
	0xfff4d4 // Golden-white
	];
	var colorIndex = Math.floor(Math.random() * rayColors.length);
	rayGraphics.tint = rayColors[colorIndex];
	self.lifeSpan = 120 + Math.random() * 180; // 2-5 seconds at 60fps
	self.age = 0;
	self.fadeInDuration = 20 + Math.random() * 20; // Quick fade in
	self.fadeOutStart = self.lifeSpan - 30; // Start fading out early
	// Animate ray appearance - brief flash effect
	tween(rayGraphics, {
		alpha: 0.08 + Math.random() * 0.12 // Very faint maximum opacity
	}, {
		duration: 300 + Math.random() * 200,
		// Quick appearance
		easing: tween.easeOut,
		onFinish: function onFinish() {
			// Hold briefly then fade out
			LK.setTimeout(function () {
				tween(rayGraphics, {
					alpha: 0.0
				}, {
					duration: 500 + Math.random() * 300,
					// Slow fade out
					easing: tween.easeIn
				});
			}, 200 + Math.random() * 400);
		}
	});
	self.update = function () {
		self.age++;
		// Subtle flickering during visibility
		if (rayGraphics.alpha > 0.02) {
			var flicker = 0.9 + Math.sin(self.age * 0.3) * 0.1;
			rayGraphics.alpha *= flicker;
		}
		// Remove when expired
		if (self.age >= self.lifeSpan) {
			self.destroy();
			for (var i = cosmicRays.length - 1; i >= 0; i--) {
				if (cosmicRays[i] === self) {
					cosmicRays.splice(i, 1);
					break;
				}
			}
		}
	};
	return self;
});
var DistantStar = Container.expand(function (x, y) {
	var self = Container.call(this);
	var starGraphics = self.attachAsset('distantStar', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = x;
	self.y = y;
	self.driftSpeedX = (Math.random() - 0.5) * 0.1;
	self.driftSpeedY = (Math.random() - 0.5) * 0.1;
	self.shimmerPhase = Math.random() * Math.PI * 2;
	self.shimmerSpeed = 0.01 + Math.random() * 0.02;
	// Extremely slow cosmic flow movement - barely perceptible
	self.cosmicFlowX = (Math.random() - 0.5) * 0.02; // Very slow horizontal flow
	self.cosmicFlowY = (Math.random() - 0.5) * 0.015; // Very slow vertical flow
	self.spiralAngle = Math.random() * Math.PI * 2; // Initial spiral position
	self.spiralSpeed = 0.0001 + Math.random() * 0.0001; // Extremely slow spiral
	self.spiralRadius = Math.random() * 0.5; // Spiral influence radius
	starGraphics.alpha = 0.2 + Math.random() * 0.4;
	starGraphics.scaleX = 0.5 + Math.random() * 0.5;
	starGraphics.scaleY = starGraphics.scaleX;
	// Star twinkling properties for independent brightness fluctuations
	self.twinkleChance = 0.003 + Math.random() * 0.002; // Small percentage chance per frame
	self.isTwinkling = false;
	self.baseBrightness = starGraphics.alpha;
	self.twinkleIntensity = 0.3 + Math.random() * 0.5; // Random twinkling intensity
	self.update = function () {
		// Very slow drift movement
		self.x += self.driftSpeedX;
		self.y += self.driftSpeedY;
		// Extremely slow cosmic flow - creates impression of vast cosmic distances
		// Only noticeable after several seconds of observation
		self.x += self.cosmicFlowX;
		self.y += self.cosmicFlowY;
		// Add subtle spiral movement flowing outward from center
		var centerX = 1024;
		var centerY = 1366;
		var spiralX = Math.cos(self.spiralAngle) * self.spiralRadius;
		var spiralY = Math.sin(self.spiralAngle) * self.spiralRadius;
		self.x += spiralX;
		self.y += spiralY;
		self.spiralAngle += self.spiralSpeed;
		// Subtle shimmer animation
		var shimmer = 0.8 + Math.sin(LK.ticks * self.shimmerSpeed + self.shimmerPhase) * 0.3;
		starGraphics.alpha = (0.2 + Math.random() * 0.4) * shimmer;
		// Independent star twinkling system - asynchronous brightness fluctuations
		if (!self.isTwinkling && Math.random() < self.twinkleChance) {
			// Start twinkling animation
			self.isTwinkling = true;
			// Create random twinkling pattern with varying durations
			var twinkleDuration = 200 + Math.random() * 400; // 200-600ms
			var targetBrightness = self.baseBrightness * (1.0 + self.twinkleIntensity);
			// Brightness increase phase
			tween(starGraphics, {
				alpha: targetBrightness,
				scaleX: starGraphics.scaleX * (1.0 + self.twinkleIntensity * 0.3),
				scaleY: starGraphics.scaleY * (1.0 + self.twinkleIntensity * 0.3)
			}, {
				duration: twinkleDuration * 0.3,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Brightness decrease phase
					tween(starGraphics, {
						alpha: self.baseBrightness * (0.7 + Math.random() * 0.3),
						scaleX: starGraphics.scaleX * (0.8 + Math.random() * 0.2),
						scaleY: starGraphics.scaleY * (0.8 + Math.random() * 0.2)
					}, {
						duration: twinkleDuration * 0.7,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							// Reset twinkling state
							self.isTwinkling = false;
							// Occasionally create a double-twinkle effect
							if (Math.random() < 0.2) {
								// Quick second twinkle after short delay
								LK.setTimeout(function () {
									if (!self.isTwinkling) {
										self.isTwinkling = true;
										tween(starGraphics, {
											alpha: targetBrightness * 0.6,
											scaleX: starGraphics.scaleX * 1.1,
											scaleY: starGraphics.scaleY * 1.1
										}, {
											duration: 150,
											easing: tween.easeInOut,
											onFinish: function onFinish() {
												self.isTwinkling = false;
											}
										});
									}
								}, 100 + Math.random() * 200);
							}
						}
					});
				}
			});
		}
		// Dynamic color tinting based on cosmic progression
		var starTints = [0xffffff,
		// Base: pure white
		0xe6e6ff,
		// Phase 1: cool blue-white
		0xddd4ff,
		// Phase 2: purple-white
		0xffd4e6 // Phase 3: warm purple-pink
		];
		var currentTint = starTints[Math.min(currentColorPhase, starTints.length - 1)];
		starGraphics.tint = currentTint;
		// Wrap around screen boundaries
		if (self.x < -10) self.x = 2058;
		if (self.x > 2058) self.x = -10;
		if (self.y < -10) self.y = 2742;
		if (self.y > 2742) self.y = -10;
	};
	return self;
});
var FluxVoid = Container.expand(function () {
	var self = Container.call(this);
	var voidGraphics = self.attachAsset('fluxVoid', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.duration = 300; // 5 seconds
	self.timer = 0;
	self.x = Math.random() * 1500 + 274;
	self.y = Math.random() * 2000 + 366;
	self.down = function (x, y, obj) {
		// 70% chance for reward, 30% for penalty
		var isReward = Math.random() < 0.7;
		var amount = Math.floor(luminaDust * 0.2); // 20% of current dust
		if (isReward) {
			luminaDust += amount;
			LK.effects.flashObject(self, 0x00ff00, 500);
		} else {
			luminaDust = Math.max(0, luminaDust - amount);
			LK.effects.flashObject(self, 0xff0000, 500);
		}
		storage.luminaDust = luminaDust;
		updateDustDisplay();
		LK.getSound('fluxEvent').play();
		// Remove this void
		self.destroy();
		for (var i = fluxVoids.length - 1; i >= 0; i--) {
			if (fluxVoids[i] === self) {
				fluxVoids.splice(i, 1);
				break;
			}
		}
	};
	self.update = function () {
		self.timer++;
		// Pulsing effect
		var pulse = 1.0 + Math.sin(LK.ticks * 0.1) * 0.3;
		voidGraphics.scaleX = pulse;
		voidGraphics.scaleY = pulse;
		// Fade out near end
		if (self.timer > self.duration - 60) {
			voidGraphics.alpha = (self.duration - self.timer) / 60;
		}
		// Remove when expired
		if (self.timer >= self.duration) {
			self.destroy();
			for (var i = fluxVoids.length - 1; i >= 0; i--) {
				if (fluxVoids[i] === self) {
					fluxVoids.splice(i, 1);
					break;
				}
			}
		}
	};
	return self;
});
var LuminaCore = Container.expand(function () {
	var self = Container.call(this);
	var coreGraphics = self.attachAsset('luminaCore', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.baseScale = 1.0;
	self.clickPower = storage.clickPower || 1;
	self.coreLevel = storage.coreLevel || 1;
	self.down = function (x, y, obj) {
		// Click effect
		tween(coreGraphics, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 100
		});
		tween(coreGraphics, {
			scaleX: self.baseScale,
			scaleY: self.baseScale
		}, {
			duration: 100
		});
		// Generate lumina dust
		var dustGenerated = self.clickPower * temporalMultiplier;
		luminaDust += dustGenerated;
		storage.luminaDust = luminaDust;
		// Spawn visual dust particle
		spawnDustParticle(self.x, self.y);
		LK.getSound('coreClick').play();
		// Update displays
		updateDustDisplay();
	};
	self.update = function () {
		// Gentle pulsing animation
		var pulseScale = 1.0 + Math.sin(LK.ticks * 0.05) * 0.1;
		coreGraphics.scaleX = self.baseScale * pulseScale;
		coreGraphics.scaleY = self.baseScale * pulseScale;
		// Color shifting based on core level
		var colorShift = Math.sin(LK.ticks * 0.02) * 0.3;
		coreGraphics.tint = 0x6a5acd + colorShift * 0x101010;
	};
	return self;
});
var LuminaEnergyWisp = Container.expand(function (x, y) {
	var self = Container.call(this);
	var wispGraphics = self.attachAsset('luminaDust', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = x;
	self.y = y;
	// Ethereal movement properties
	self.flowSpeed = 0.3 + Math.random() * 0.5; // Gentle flowing speed
	self.flowDirection = Math.random() * Math.PI * 2; // Random initial direction
	self.flowPhase = Math.random() * Math.PI * 2;
	self.waveAmplitude = 30 + Math.random() * 40; // Sine wave amplitude for ethereal movement
	self.waveFrequency = 0.008 + Math.random() * 0.004; // Wave frequency for organic flow
	self.lifeSpan = 1800 + Math.random() * 1800; // 30-60 seconds at 60fps
	self.age = 0;
	// Energy attraction to Lumina Core for permeating effect
	self.coreAttraction = 0.02 + Math.random() * 0.01; // Subtle attraction force
	self.orbitRadius = 150 + Math.random() * 200; // Preferred orbit distance
	self.spiralTendency = (Math.random() - 0.5) * 0.003; // Slight spiral movement
	// Visual properties for ethereal appearance
	wispGraphics.alpha = 0.0; // Start invisible
	wispGraphics.scaleX = 0.4 + Math.random() * 0.3; // Small ethereal particles
	wispGraphics.scaleY = wispGraphics.scaleX;
	wispGraphics.tint = 0x9370db; // Lumina purple energy color
	// Fade in effect
	tween(wispGraphics, {
		alpha: 0.15 + Math.random() * 0.15 // Subtle ethereal visibility
	}, {
		duration: 1000 + Math.random() * 1000,
		easing: tween.easeOut
	});
	self.update = function () {
		self.age++;
		// Ethereal flowing movement with wave patterns
		var waveOffsetX = Math.sin(self.age * self.waveFrequency + self.flowPhase) * self.waveAmplitude;
		var waveOffsetY = Math.cos(self.age * self.waveFrequency * 0.7 + self.flowPhase) * self.waveAmplitude * 0.6;
		// Flow in direction with ethereal wave motion
		self.x += Math.cos(self.flowDirection) * self.flowSpeed + waveOffsetX * 0.01;
		self.y += Math.sin(self.flowDirection) * self.flowSpeed + waveOffsetY * 0.01;
		// Subtle attraction to Lumina Core for energy permeation effect
		var coreX = 1024;
		var coreY = 1366;
		var distanceToCore = Math.sqrt((self.x - coreX) * (self.x - coreX) + (self.y - coreY) * (self.y - coreY));
		// Apply gentle attraction when not too close
		if (distanceToCore > self.orbitRadius) {
			var attractionX = (coreX - self.x) / distanceToCore * self.coreAttraction;
			var attractionY = (coreY - self.y) / distanceToCore * self.coreAttraction;
			self.x += attractionX;
			self.y += attractionY;
		}
		// Add subtle spiral movement around core
		var angleToCore = Math.atan2(self.y - coreY, self.x - coreX);
		angleToCore += self.spiralTendency;
		var spiralX = coreX + Math.cos(angleToCore) * distanceToCore;
		var spiralY = coreY + Math.sin(angleToCore) * distanceToCore;
		self.x += (spiralX - self.x) * 0.01; // Very subtle spiral influence
		self.y += (spiralY - self.y) * 0.01;
		// Ethereal pulsing and energy fluctuation
		var energyPulse = 0.7 + Math.sin(self.age * 0.03 + self.flowPhase) * 0.3;
		var energyFlicker = 0.8 + Math.sin(self.age * 0.08) * 0.2;
		wispGraphics.alpha *= energyPulse * energyFlicker;
		// Subtle scale breathing for ethereal effect
		var scaleBreathing = 1.0 + Math.sin(self.age * 0.02 + self.flowPhase) * 0.15;
		wispGraphics.scaleX = (0.4 + Math.random() * 0.3) * scaleBreathing;
		wispGraphics.scaleY = wispGraphics.scaleX;
		// Gentle rotation to enhance ethereal movement
		wispGraphics.rotation += 0.005 + Math.sin(self.age * 0.01) * 0.003;
		// Color shifting for energy effect - hints at Lumina Core's influence
		var colorShift = Math.sin(self.age * 0.015) * 0.1;
		var r = 0.58 + colorShift; // Purple base with shifting
		var g = 0.44 + colorShift * 0.5;
		var b = 0.86 + colorShift * 0.3;
		var shiftedColor = Math.floor(r * 255) << 16 | Math.floor(g * 255) << 8 | Math.floor(b * 255);
		wispGraphics.tint = shiftedColor;
		// Fade out near end of lifespan
		if (self.age > self.lifeSpan - 600) {
			// Last 10 seconds
			var fadeProgress = (self.lifeSpan - self.age) / 600;
			wispGraphics.alpha *= fadeProgress;
		}
		// Remove when expired
		if (self.age >= self.lifeSpan) {
			self.destroy();
			for (var i = luminaEnergyWisps.length - 1; i >= 0; i--) {
				if (luminaEnergyWisps[i] === self) {
					luminaEnergyWisps.splice(i, 1);
					break;
				}
			}
		}
	};
	return self;
});
var NebulaCloud = Container.expand(function (x, y, scale, speed) {
	var self = Container.call(this);
	var cloudGraphics = self.attachAsset('nebulaCloud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = x;
	self.y = y;
	self.baseScale = scale || 1.0;
	self.speed = speed || 0.001;
	self.phaseOffset = Math.random() * Math.PI * 2;
	cloudGraphics.scaleX = self.baseScale;
	cloudGraphics.scaleY = self.baseScale;
	cloudGraphics.alpha = 0.3;
	// Undulation properties for organic texture shifting
	self.undulationPhaseX = Math.random() * Math.PI * 2;
	self.undulationPhaseY = Math.random() * Math.PI * 2;
	self.undulationSpeedX = 0.003 + Math.random() * 0.002; // Very slow undulation
	self.undulationSpeedY = 0.002 + Math.random() * 0.003;
	self.undulationIntensity = 0.15 + Math.random() * 0.1; // Subtle intensity variation
	self.colorShiftPhase = Math.random() * Math.PI * 2;
	self.colorShiftSpeed = 0.001 + Math.random() * 0.0005; // Very slow color blending
	self.expansionPhase = Math.random() * Math.PI * 2;
	self.expansionSpeed = 0.0008 + Math.random() * 0.0004; // Slow expansion/contraction
	// Initialize very slow breathing/swirling tween animation
	self.breathingCycle = function () {
		// Slow breathing scale animation (8-12 second cycles)
		var breathDuration = 8000 + Math.random() * 4000; // 8-12 seconds
		var breathScale = 0.95 + Math.random() * 0.1; // Subtle scale variation
		tween(cloudGraphics, {
			scaleX: self.baseScale * breathScale,
			scaleY: self.baseScale * breathScale * 0.8
		}, {
			duration: breathDuration,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				// Breathe back out
				tween(cloudGraphics, {
					scaleX: self.baseScale,
					scaleY: self.baseScale * 0.8
				}, {
					duration: breathDuration,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						// Continue the breathing cycle
						self.breathingCycle();
					}
				});
			}
		});
	};
	// Start the breathing cycle
	self.breathingCycle();
	// Initialize continuous undulation animation system
	self.undulationCycle = function () {
		// Create continuous, non-looping undulation with varying parameters
		var undulationDuration = 45000 + Math.random() * 30000; // 45-75 seconds for very slow movement
		var targetScaleX = self.baseScale * (0.7 + Math.random() * 0.6); // Wide range of scale variation
		var targetScaleY = self.baseScale * (0.8 + Math.random() * 0.4); // Different Y scaling for organic feel
		var targetAlpha = 0.2 + Math.random() * 0.3; // Subtle alpha variation
		// Create organic, flowing undulation with easing
		tween(cloudGraphics, {
			scaleX: targetScaleX,
			scaleY: targetScaleY,
			alpha: targetAlpha
		}, {
			duration: undulationDuration,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				// Continue with new random parameters for infinite variation
				self.undulationCycle();
			}
		});
		// Add secondary undulation layer for more complex movement
		LK.setTimeout(function () {
			var secondaryDuration = 35000 + Math.random() * 25000; // Slightly different timing
			var secondaryScaleX = self.baseScale * (0.8 + Math.random() * 0.4);
			var secondarySkew = (Math.random() - 0.5) * 0.3; // Add subtle skewing effect
			tween(cloudGraphics, {
				scaleX: secondaryScaleX,
				rotation: cloudGraphics.rotation + secondarySkew
			}, {
				duration: secondaryDuration,
				easing: tween.easeInOut
			});
		}, undulationDuration * 0.3); // Offset timing for layered effect
	};
	// Start undulation cycle with random delay
	LK.setTimeout(function () {
		self.undulationCycle();
	}, Math.random() * 10000);
	// Add subtle swirling motion with tween
	self.swirlingCycle = function () {
		var swirlingDuration = 15000 + Math.random() * 10000; // 15-25 seconds
		var swirlingIntensity = 20 + Math.random() * 30; // Subtle movement range
		var targetX = self.x + (Math.random() - 0.5) * swirlingIntensity;
		var targetY = self.y + (Math.random() - 0.5) * swirlingIntensity;
		tween(self, {
			x: targetX,
			y: targetY
		}, {
			duration: swirlingDuration,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				// Continue the swirling cycle
				self.swirlingCycle();
			}
		});
	};
	// Start the swirling cycle with a random delay
	LK.setTimeout(function () {
		self.swirlingCycle();
	}, Math.random() * 5000);
	self.update = function () {
		// Gentle floating movement
		self.x += Math.sin(LK.ticks * self.speed + self.phaseOffset) * 0.2;
		self.y += Math.cos(LK.ticks * self.speed * 0.7 + self.phaseOffset) * 0.15;
		// Continuous organic undulation - creates flowing, shifting texture effect
		var undulationX = Math.sin(LK.ticks * self.undulationSpeedX + self.undulationPhaseX) * self.undulationIntensity;
		var undulationY = Math.cos(LK.ticks * self.undulationSpeedY + self.undulationPhaseY) * self.undulationIntensity;
		var undulationScale = 1.0 + Math.sin(LK.ticks * self.undulationSpeedX * 0.5 + self.undulationPhaseX) * 0.08;
		// Apply undulation to create organic texture shifting
		cloudGraphics.scaleX *= (1.0 + undulationX) * undulationScale;
		cloudGraphics.scaleY *= (1.0 + undulationY) * undulationScale * 0.8;
		// Slow expansion/contraction cycles - simulates breathing nebula
		var expansionCycle = Math.sin(LK.ticks * self.expansionSpeed + self.expansionPhase) * 0.12;
		cloudGraphics.scaleX *= 1.0 + expansionCycle;
		cloudGraphics.scaleY *= 1.0 + expansionCycle * 0.7;
		// Continuous color blending and shifting for internal wisps effect
		var colorWaveR = Math.sin(LK.ticks * self.colorShiftSpeed + self.colorShiftPhase) * 0.15;
		var colorWaveG = Math.cos(LK.ticks * self.colorShiftSpeed * 1.3 + self.colorShiftPhase) * 0.1;
		var colorWaveB = Math.sin(LK.ticks * self.colorShiftSpeed * 0.8 + self.colorShiftPhase + Math.PI) * 0.2;
		// Progressive color palette with Core evolution-based transitions
		var progressiveColors = [0x2c1b47,
		// Base: dark purple-blue
		0x3d2b5d,
		// Evolution 1: deeper purple
		0x4a3373,
		// Evolution 2: warmer purple
		0x6b4ba6,
		// Evolution 3: vibrant violet
		0x8a6bc4 // Transcendence: warm violet with energy
		];
		var baseColor = progressiveColors[Math.min(currentColorPhase, progressiveColors.length - 1)];
		// Enhanced color blending for evolution phases
		if (coreEvolutions > 0) {
			// Add golden hints during advanced evolutions
			var goldenInfluence = Math.min(coreEvolutions * 0.1, 0.3);
			var r = (baseColor >> 16 & 0xFF) / 255.0;
			var g = (baseColor >> 8 & 0xFF) / 255.0;
			var b = (baseColor & 0xFF) / 255.0;
			// Blend in golden warmth
			r = Math.min(1.0, r + goldenInfluence * 0.2);
			g = Math.min(1.0, g + goldenInfluence * 0.15);
			baseColor = Math.floor(r * 255) << 16 | Math.floor(g * 255) << 8 | Math.floor(b * 255);
		}
		// Extract RGB components and apply organic color shifting
		var r = (baseColor >> 16 & 0xFF) / 255.0;
		var g = (baseColor >> 8 & 0xFF) / 255.0;
		var b = (baseColor & 0xFF) / 255.0;
		// Apply continuous color waves for internal wisp blending
		r = Math.max(0, Math.min(1, r + colorWaveR));
		g = Math.max(0, Math.min(1, g + colorWaveG));
		b = Math.max(0, Math.min(1, b + colorWaveB));
		// Reconstruct color with organic shifting
		var shiftedColor = Math.floor(r * 255) << 16 | Math.floor(g * 255) << 8 | Math.floor(b * 255);
		cloudGraphics.tint = shiftedColor;
		// Gentle alpha breathing with undulation
		var alphaPulse = 0.3 + Math.sin(LK.ticks * self.speed * 1.5 + self.phaseOffset) * 0.1;
		var alphaUndulation = Math.cos(LK.ticks * self.undulationSpeedY + self.undulationPhaseY) * 0.05;
		cloudGraphics.alpha = Math.max(0.1, Math.min(0.6, alphaPulse + alphaUndulation));
		// Very slow rotation with slight variation
		var rotationVariation = Math.sin(LK.ticks * self.undulationSpeedX * 0.3) * 0.002;
		cloudGraphics.rotation += self.speed * 0.5 + rotationVariation;
	};
	return self;
});
var SpireNode = Container.expand(function (angle, distance) {
	var self = Container.call(this);
	var nodeGraphics = self.attachAsset('spireNode', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.angle = angle;
	self.distance = distance;
	self.dustPerSecond = 0.5;
	self.lastDustTime = LK.ticks;
	self.decayTimer = 0;
	self.isDecaying = false;
	self.update = function () {
		// Orbital movement
		self.x = 1024 + Math.cos(self.angle + LK.ticks * 0.01) * self.distance;
		self.y = 1366 + Math.sin(self.angle + LK.ticks * 0.01) * self.distance;
		// Generate dust automatically
		if (LK.ticks - self.lastDustTime >= 60) {
			// Every second at 60fps
			if (!self.isDecaying) {
				luminaDust += self.dustPerSecond;
				storage.luminaDust = luminaDust;
				updateDustDisplay();
				spawnDustParticle(self.x, self.y);
			}
			self.lastDustTime = LK.ticks;
		}
		// Handle decay system
		self.decayTimer++;
		if (self.decayTimer > 1800) {
			// 30 seconds at 60fps
			self.isDecaying = true;
			nodeGraphics.tint = 0xff4444;
		}
		// Gentle rotation
		nodeGraphics.rotation += 0.02;
	};
	self.repair = function () {
		self.isDecaying = false;
		self.decayTimer = 0;
		nodeGraphics.tint = 0xffffff;
		// Repair cost
		var repairCost = 10;
		if (luminaDust >= repairCost) {
			luminaDust -= repairCost;
			storage.luminaDust = luminaDust;
			updateDustDisplay();
		}
	};
	self.down = function (x, y, obj) {
		if (self.isDecaying) {
			self.repair();
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x1a0d2e
});

/**** 
* Game Code
****/ 
// Game state variables
var luminaDust = storage.luminaDust || 0;
var spireNodes = [];
var fluxVoids = [];
var dustParticles = [];
var nebulaClouds = [];
var distantStars = [];
var cosmicParticles = []; // Track low-density cosmic particles
var luminaEnergyWisps = []; // Track ethereal Lumina energy wisps
var cosmicRays = []; // Track faint cosmic ray beams
var cosmicBeams = []; // Track ethereal traversing light beams
var temporalMultiplier = 1.0;
var nextFluxTime = LK.ticks + Math.random() * 1800 + 1200; // 20-50 seconds
var nextTemporalTime = LK.ticks + Math.random() * 3600 + 1800; // 30-90 seconds
var nextCosmicParticleTime = LK.ticks + Math.random() * 900 + 600; // 10-25 seconds between spawns
// Color palette for cosmic atmosphere progression
var colorPalette = {
	baseBackground: 0x1a0d2e,
	// Deep purple void
	earlyNebula: 0x2c1b47,
	// Dark purple-blue
	midNebula: 0x3d2b5d,
	// Deeper purple
	lateNebula: 0x4a3373,
	// Warmer purple
	advancedNebula: 0x5d4088 // Purple with golden hints
};
var currentColorPhase = storage.colorPhase || 0; // 0-4 representing progression through color phases
// Core evolution tracking for significant transformations
var coreEvolutions = storage.coreEvolutions || 0;
var lastEvolutionCheck = storage.lastEvolutionCheck || 0;
var transcendenceLevel = storage.transcendenceLevel || 0;
// UI Elements
var dustDisplay = new Text2('Lumina Dust: 0', {
	size: 80,
	fill: 0xFFD700
});
dustDisplay.anchor.set(0.5, 0);
LK.gui.top.addChild(dustDisplay);
var clickPowerDisplay = new Text2('Click Power: 1x', {
	size: 60,
	fill: 0xFFFFFF
});
clickPowerDisplay.anchor.set(0, 0);
clickPowerDisplay.x = 50;
clickPowerDisplay.y = 150;
LK.gui.topLeft.addChild(clickPowerDisplay);
var nodeCountDisplay = new Text2('Spire Nodes: 0', {
	size: 60,
	fill: 0x40E0D0
});
nodeCountDisplay.anchor.set(0, 0);
nodeCountDisplay.x = 50;
nodeCountDisplay.y = 220;
LK.gui.topLeft.addChild(nodeCountDisplay);
var temporalDisplay = new Text2('Temporal: 1.0x', {
	size: 50,
	fill: 0xFF69B4
});
temporalDisplay.anchor.set(1, 0);
LK.gui.topRight.addChild(temporalDisplay);
// Purchase buttons
var buyNodeButton = new Text2('Buy Spire Node\nCost: 50 Dust', {
	size: 50,
	fill: 0x40E0D0
});
buyNodeButton.anchor.set(0.5, 1);
LK.gui.bottom.addChild(buyNodeButton);
var upgradeClickButton = new Text2('Upgrade Click\nCost: 100 Dust', {
	size: 50,
	fill: 0xFFD700
});
upgradeClickButton.anchor.set(0.5, 1);
upgradeClickButton.y = -120;
LK.gui.bottom.addChild(upgradeClickButton);
// Create nebulous gas clouds for atmospheric depth
for (var i = 0; i < 6; i++) {
	var cloudX = Math.random() * 2048;
	var cloudY = Math.random() * 2732;
	var cloudScale = 0.8 + Math.random() * 0.6;
	var cloudSpeed = 0.0005 + Math.random() * 0.001;
	var cloud = game.addChild(new NebulaCloud(cloudX, cloudY, cloudScale, cloudSpeed));
	nebulaClouds.push(cloud);
}
// Create scattered distant stars for ambient particle drift
for (var i = 0; i < 150; i++) {
	var starX = Math.random() * 2048;
	var starY = Math.random() * 2732;
	var star = game.addChild(new DistantStar(starX, starY));
	distantStars.push(star);
}
// Initialize starfield layer movement for cosmic flow
var starfieldFlowDirection = Math.random() * Math.PI * 2; // Random flow direction
var starfieldFlowSpeed = 0.008 + Math.random() * 0.004; // Extremely slow flow speed
var starfieldSpiralCenter = {
	x: 1024,
	y: 1366
}; // Spiral center point
// Create the main Lumina Core
var luminaCore = game.addChild(new LuminaCore());
luminaCore.x = 1024;
luminaCore.y = 1366;
// Load existing spire nodes
var savedNodeCount = storage.spireNodeCount || 0;
for (var i = 0; i < savedNodeCount; i++) {
	var angle = i / savedNodeCount * Math.PI * 2;
	var distance = 200 + i * 30;
	var node = game.addChild(new SpireNode(angle, distance));
	spireNodes.push(node);
}
function updateDustDisplay() {
	dustDisplay.setText('Lumina Dust: ' + Math.floor(luminaDust));
}
function updateClickPowerDisplay() {
	clickPowerDisplay.setText('Click Power: ' + luminaCore.clickPower + 'x');
}
function updateNodeCountDisplay() {
	nodeCountDisplay.setText('Spire Nodes: ' + spireNodes.length);
}
function updateTemporalDisplay() {
	temporalDisplay.setText('Temporal: ' + temporalMultiplier.toFixed(1) + 'x');
}
function spawnDustParticle(x, y) {
	var particle = LK.getAsset('luminaDust', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	particle.x = x + (Math.random() - 0.5) * 100;
	particle.y = y + (Math.random() - 0.5) * 100;
	particle.alpha = 1.0;
	particle.timer = 0;
	particle.maxTime = 60; // 1 second
	game.addChild(particle);
	dustParticles.push(particle);
	// Animate particle
	var targetY = particle.y - 100;
	tween(particle, {
		y: targetY,
		alpha: 0
	}, {
		duration: 1000,
		onFinish: function onFinish() {
			particle.destroy();
			for (var i = dustParticles.length - 1; i >= 0; i--) {
				if (dustParticles[i] === particle) {
					dustParticles.splice(i, 1);
					break;
				}
			}
		}
	});
}
function createFluxVoid() {
	var fluxVoid = game.addChild(new FluxVoid());
	fluxVoids.push(fluxVoid);
}
function spawnCosmicParticle() {
	// Low-density spawning - only spawn if particle count is low
	if (cosmicParticles.length < 8) {
		// Maximum 8 particles at once for low density
		// Spawn near edges of screen for natural drift across view
		var spawnSide = Math.floor(Math.random() * 4);
		var x, y;
		switch (spawnSide) {
			case 0:
				// Top edge
				x = Math.random() * 2048;
				y = -100;
				break;
			case 1:
				// Right edge
				x = 2148;
				y = Math.random() * 2732;
				break;
			case 2:
				// Bottom edge
				x = Math.random() * 2048;
				y = 2832;
				break;
			case 3:
				// Left edge
				x = -100;
				y = Math.random() * 2732;
				break;
		}
		var particle = game.addChild(new CosmicParticle(x, y));
		cosmicParticles.push(particle);
	}
}
function spawnLuminaEnergyWisp() {
	// Moderate density spawning - maintain ethereal energy presence
	if (luminaEnergyWisps.length < 12) {
		// Maximum 12 wisps for ethereal atmosphere
		// Spawn in various patterns around the environment
		var spawnPattern = Math.floor(Math.random() * 3);
		var x, y;
		switch (spawnPattern) {
			case 0:
				// Spawn around Lumina Core area for energy emission effect
				var angle = Math.random() * Math.PI * 2;
				var distance = 300 + Math.random() * 200;
				x = 1024 + Math.cos(angle) * distance;
				y = 1366 + Math.sin(angle) * distance;
				break;
			case 1:
				// Spawn from screen edges flowing inward
				var edge = Math.floor(Math.random() * 4);
				switch (edge) {
					case 0:
						x = Math.random() * 2048;
						y = -50;
						break;
					// Top
					case 1:
						x = 2098;
						y = Math.random() * 2732;
						break;
					// Right
					case 2:
						x = Math.random() * 2048;
						y = 2782;
						break;
					// Bottom
					case 3:
						x = -50;
						y = Math.random() * 2732;
						break;
					// Left
				}
				break;
			case 2:
				// Spawn randomly throughout environment for permeating effect
				x = Math.random() * 2048;
				y = Math.random() * 2732;
				break;
		}
		var wisp = game.addChild(new LuminaEnergyWisp(x, y));
		luminaEnergyWisps.push(wisp);
	}
}
function spawnCosmicRay() {
	// Very low frequency spawning - only spawn occasionally
	if (cosmicRays.length < 3) {
		// Maximum 3 rays at once for subtlety
		// Choose ray path type
		var rayType = Math.floor(Math.random() * 4);
		var startX, startY, endX, endY;
		switch (rayType) {
			case 0:
				// Diagonal from top-left to bottom-right
				startX = -100 + Math.random() * 500;
				startY = -100 + Math.random() * 300;
				endX = 1548 + Math.random() * 500;
				endY = 2432 + Math.random() * 300;
				break;
			case 1:
				// Diagonal from top-right to bottom-left
				startX = 1548 + Math.random() * 500;
				startY = -100 + Math.random() * 300;
				endX = -100 + Math.random() * 500;
				endY = 2432 + Math.random() * 300;
				break;
			case 2:
				// Horizontal across screen
				startX = -200;
				startY = Math.random() * 2732;
				endX = 2248;
				endY = startY + (Math.random() - 0.5) * 400; // Slight curve
				break;
			case 3:
				// Vertical or steep diagonal
				startX = Math.random() * 2048;
				startY = -200;
				endX = startX + (Math.random() - 0.5) * 800;
				endY = 2932;
				break;
		}
		var ray = game.addChild(new CosmicRay(startX, startY, endX, endY));
		cosmicRays.push(ray);
	}
}
function spawnCosmicBeam() {
	// Rare spawning - very infrequent ethereal light beams
	if (cosmicBeams.length < 2) {
		// Maximum 2 beams at once for rarity
		var beam = game.addChild(new CosmicBeam());
		cosmicBeams.push(beam);
	}
}
function triggerTemporalDisruption() {
	// Random multiplier between 0.5x and 1.5x
	temporalMultiplier = 0.5 + Math.random();
	updateTemporalDisplay();
	// Effect lasts 10 seconds
	LK.setTimeout(function () {
		temporalMultiplier = 1.0;
		updateTemporalDisplay();
	}, 10000);
	LK.effects.flashScreen(0x4169e1, 1000);
}
function triggerNebulaColorEvolution() {
	// Dramatic color palette shift for all nebula clouds
	var evolutionColors = [[0x2c1b47, 0x3d2b5d],
	// Early: cool blues and purples
	[0x4a3373, 0x5d4088],
	// Mid: warmer purples
	[0x6b4ba6, 0x7b5bb6],
	// Advanced: vibrant violets
	[0x8a6bc4, 0x9370db],
	// Transcendent: warm violets with energy
	[0xa478d4, 0xb19cd9] // Ultimate: violet-green with golden hints
	];
	var currentColors = evolutionColors[Math.min(coreEvolutions, evolutionColors.length - 1)];
	// Apply evolution to all nebula clouds with staggered timing
	for (var i = 0; i < nebulaClouds.length; i++) {
		var cloud = nebulaClouds[i];
		var evolutionDelay = i * 500; // Stagger each cloud by 500ms
		var targetColor = currentColors[i % currentColors.length];
		LK.setTimeout(function (cloudRef, color) {
			return function () {
				// Dramatic color transition
				tween(cloudRef.children[0], {
					tint: color
				}, {
					duration: 8000,
					// 8 second evolution
					easing: tween.easeInOut
				});
				// Temporary scale pulse during evolution
				tween(cloudRef.children[0], {
					scaleX: cloudRef.baseScale * 1.3,
					scaleY: cloudRef.baseScale * 1.3
				}, {
					duration: 2000,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(cloudRef.children[0], {
							scaleX: cloudRef.baseScale,
							scaleY: cloudRef.baseScale
						}, {
							duration: 6000,
							easing: tween.easeInOut
						});
					}
				});
			};
		}(cloud, targetColor), evolutionDelay);
	}
}
function triggerCosmicTranscendence() {
	// Ultimate transformation - shift to warm violets and green hints
	var transcendentColors = [0xa478d4, 0xb19cd9, 0x98d982]; // Violet-green palette
	// Transform all cosmic elements
	for (var i = 0; i < nebulaClouds.length; i++) {
		var cloud = nebulaClouds[i];
		var transcendentColor = transcendentColors[i % transcendentColors.length];
		// Ultimate color transformation
		tween(cloud.children[0], {
			tint: transcendentColor
		}, {
			duration: 12000,
			// 12 second transcendence
			easing: tween.easeInOut
		});
		// Cosmic energy surge effect
		tween(cloud.children[0], {
			alpha: 0.8,
			// Brighter during transcendence
			scaleX: cloud.baseScale * 1.5,
			scaleY: cloud.baseScale * 1.5
		}, {
			duration: 3000,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(cloud.children[0], {
					alpha: 0.4,
					scaleX: cloud.baseScale * 1.1,
					scaleY: cloud.baseScale * 1.1
				}, {
					duration: 9000,
					easing: tween.easeInOut
				});
			}
		});
	}
	// Transform distant stars to match transcendent energy
	for (var i = 0; i < distantStars.length; i++) {
		var star = distantStars[i];
		if (Math.random() < 0.6) {
			// 60% of stars participate
			tween(star.children[0], {
				tint: 0xffd700,
				// Golden energy
				alpha: 0.8,
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 6000,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					tween(star.children[0], {
						alpha: 0.4,
						scaleX: 0.8,
						scaleY: 0.8
					}, {
						duration: 6000,
						easing: tween.easeInOut
					});
				}
			});
		}
	}
}
// Button handlers
buyNodeButton.down = function (x, y, obj) {
	var cost = 50 + spireNodes.length * 25;
	if (luminaDust >= cost) {
		luminaDust -= cost;
		storage.luminaDust = luminaDust;
		var angle = spireNodes.length / (spireNodes.length + 1) * Math.PI * 2;
		var distance = 200 + spireNodes.length * 30;
		var node = game.addChild(new SpireNode(angle, distance));
		spireNodes.push(node);
		storage.spireNodeCount = spireNodes.length;
		updateDustDisplay();
		updateNodeCountDisplay();
		LK.getSound('purchase').play();
		// Update button cost display
		var newCost = 50 + spireNodes.length * 25;
		buyNodeButton.setText('Buy Spire Node\nCost: ' + newCost + ' Dust');
	}
};
upgradeClickButton.down = function (x, y, obj) {
	var cost = 100 * luminaCore.clickPower;
	if (luminaDust >= cost) {
		luminaDust -= cost;
		storage.luminaDust = luminaDust;
		luminaCore.clickPower++;
		storage.clickPower = luminaCore.clickPower;
		updateDustDisplay();
		updateClickPowerDisplay();
		LK.getSound('purchase').play();
		// Update button cost display
		var newCost = 100 * luminaCore.clickPower;
		upgradeClickButton.setText('Upgrade Click\nCost: ' + newCost + ' Dust');
	}
};
// Initialize displays
updateDustDisplay();
updateClickPowerDisplay();
updateNodeCountDisplay();
updateTemporalDisplay();
// Update button costs
var nodeCost = 50 + spireNodes.length * 25;
buyNodeButton.setText('Buy Spire Node\nCost: ' + nodeCost + ' Dust');
var clickCost = 100 * luminaCore.clickPower;
upgradeClickButton.setText('Upgrade Click\nCost: ' + clickCost + ' Dust');
// Play ambient music
LK.playMusic('cosmicAmbient');
// Initialize cosmic breathing cycle - creates universe-wide living rhythm
var _cosmicBreathingCycle = function cosmicBreathingCycle() {
	var breathDuration = 25000 + Math.random() * 15000; // 25-40 second cycles
	var breathIntensity = 0.03 + Math.random() * 0.02; // Subtle breathing intensity
	var breathPhase = Math.random() * Math.PI * 2;
	// Apply cosmic breathing to all elements for unified living background
	for (var i = 0; i < nebulaClouds.length; i++) {
		var cloud = nebulaClouds[i];
		var cloudBreathIntensity = breathIntensity * (0.8 + Math.random() * 0.4);
		tween(cloud.children[0], {
			alpha: cloud.children[0].alpha * (1.0 + cloudBreathIntensity),
			scaleX: cloud.baseScale * (1.0 + cloudBreathIntensity),
			scaleY: cloud.baseScale * (1.0 + cloudBreathIntensity * 0.7)
		}, {
			duration: breathDuration * 0.5,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(cloud.children[0], {
					alpha: cloud.children[0].alpha * (1.0 - cloudBreathIntensity * 0.5),
					scaleX: cloud.baseScale * (1.0 - cloudBreathIntensity * 0.3),
					scaleY: cloud.baseScale * (1.0 - cloudBreathIntensity * 0.2)
				}, {
					duration: breathDuration * 0.5,
					easing: tween.easeInOut
				});
			}
		});
	}
	// Apply subtle breathing to distant stars
	for (var i = 0; i < distantStars.length; i++) {
		var star = distantStars[i];
		if (Math.random() < 0.4) {
			// 40% of stars participate in cosmic breathing
			var starBreathIntensity = breathIntensity * 2.0; // Stars have more pronounced breathing
			tween(star.children[0], {
				alpha: star.children[0].alpha * (1.0 + starBreathIntensity),
				scaleX: star.children[0].scaleX * (1.0 + starBreathIntensity * 0.5),
				scaleY: star.children[0].scaleY * (1.0 + starBreathIntensity * 0.5)
			}, {
				duration: breathDuration * 0.6,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					tween(star.children[0], {
						alpha: star.children[0].alpha * (1.0 - starBreathIntensity * 0.7),
						scaleX: star.children[0].scaleX * (1.0 - starBreathIntensity * 0.3),
						scaleY: star.children[0].scaleY * (1.0 - starBreathIntensity * 0.3)
					}, {
						duration: breathDuration * 0.4,
						easing: tween.easeInOut
					});
				}
			});
		}
	}
	// Continue the cosmic breathing cycle infinitely
	LK.setTimeout(function () {
		_cosmicBreathingCycle();
	}, breathDuration);
};
// Start the cosmic breathing cycle with initial delay
LK.setTimeout(function () {
	_cosmicBreathingCycle();
}, 5000); // Start after 5 seconds
// Initialize starfield layer cosmic flow animation
var _starfieldCosmicFlow = function starfieldCosmicFlow() {
	var flowDuration = 60000 + Math.random() * 30000; // 60-90 second cycles
	var flowIntensity = 0.01 + Math.random() * 0.005; // Very subtle flow
	// Create slow, constant movement across entire starfield
	for (var i = 0; i < distantStars.length; i++) {
		var star = distantStars[i];
		// Calculate flow direction - gentle drift across screen
		var flowX = Math.cos(starfieldFlowDirection) * flowIntensity;
		var flowY = Math.sin(starfieldFlowDirection) * flowIntensity;
		// Apply extremely slow cosmic flow with tween for smooth movement
		tween(star, {
			x: star.x + flowX * 200,
			// Very slow movement over long duration
			y: star.y + flowY * 150
		}, {
			duration: flowDuration,
			easing: tween.linear // Constant movement speed
		});
	}
	// Gradually change flow direction for organic cosmic movement
	var newFlowDirection = starfieldFlowDirection + (Math.random() - 0.5) * 0.2;
	tween({
		value: starfieldFlowDirection
	}, {
		value: newFlowDirection
	}, {
		duration: flowDuration,
		easing: tween.linear,
		onFinish: function onFinish() {
			starfieldFlowDirection = newFlowDirection;
		}
	});
	// Continue the cosmic flow cycle
	LK.setTimeout(function () {
		_starfieldCosmicFlow();
	}, flowDuration);
};
// Start starfield cosmic flow with initial delay
LK.setTimeout(function () {
	_starfieldCosmicFlow();
}, 10000); // Start after 10 seconds
game.update = function () {
	// Handle flux void spawning
	if (LK.ticks >= nextFluxTime) {
		createFluxVoid();
		nextFluxTime = LK.ticks + Math.random() * 1800 + 1200; // 20-50 seconds
	}
	// Handle temporal disruptions
	if (LK.ticks >= nextTemporalTime) {
		triggerTemporalDisruption();
		nextTemporalTime = LK.ticks + Math.random() * 3600 + 1800; // 30-90 seconds
	}
	// Handle low-density cosmic particle spawning
	if (LK.ticks >= nextCosmicParticleTime) {
		spawnCosmicParticle();
		nextCosmicParticleTime = LK.ticks + Math.random() * 1800 + 1200; // 20-50 seconds between spawns for low density
	}
	// Handle ethereal Lumina energy wisp spawning for permeating energy effect
	if (LK.ticks % 180 === 0) {
		// Every 3 seconds - regular ethereal energy emission
		spawnLuminaEnergyWisp();
	}
	// Increased energy emission during Core activity
	if (LK.ticks % 60 === 0 && spireNodes.length > 0) {
		// Every second when nodes are active
		if (Math.random() < 0.3) {
			// 30% chance for additional ethereal energy
			spawnLuminaEnergyWisp();
		}
	}
	// Clean up expired dust particles
	for (var i = dustParticles.length - 1; i >= 0; i--) {
		var particle = dustParticles[i];
		particle.timer++;
		if (particle.timer >= particle.maxTime) {
			particle.destroy();
			dustParticles.splice(i, 1);
		}
	}
	// Handle nebula cloud boundary wrapping
	for (var i = 0; i < nebulaClouds.length; i++) {
		var cloud = nebulaClouds[i];
		// Wrap around screen boundaries
		if (cloud.x < -400) cloud.x = 2048 + 400;
		if (cloud.x > 2048 + 400) cloud.x = -400;
		if (cloud.y < -300) cloud.y = 2732 + 300;
		if (cloud.y > 2732 + 300) cloud.y = -300;
	}
	// Clean up cosmic particles that have drifted too far off screen
	for (var i = cosmicParticles.length - 1; i >= 0; i--) {
		var particle = cosmicParticles[i];
		if (particle.x < -200 || particle.x > 2248 || particle.y < -200 || particle.y > 2932) {
			particle.destroy();
			cosmicParticles.splice(i, 1);
		}
	}
	// Clean up Lumina energy wisps that have drifted too far off screen
	for (var i = luminaEnergyWisps.length - 1; i >= 0; i--) {
		var wisp = luminaEnergyWisps[i];
		if (wisp.x < -300 || wisp.x > 2348 || wisp.y < -300 || wisp.y > 3032) {
			wisp.destroy();
			luminaEnergyWisps.splice(i, 1);
		}
	}
	// Clean up cosmic beams that have completed traversal or expired
	for (var i = cosmicBeams.length - 1; i >= 0; i--) {
		var beam = cosmicBeams[i];
		if (beam.x < -400 || beam.x > 2448 || beam.y < -400 || beam.y > 3132) {
			beam.destroy();
			cosmicBeams.splice(i, 1);
		}
	}
	// Handle very occasional cosmic ray spawning - rare, brief light beams
	if (LK.ticks % 1200 === 0) {
		// Every 20 seconds check for potential spawn
		if (Math.random() < 0.15) {
			// 15% chance - very rare occurrence
			spawnCosmicRay();
		}
	}
	// Handle extremely rare cosmic beam spawning - ethereal light traversal
	if (LK.ticks % 2400 === 0) {
		// Every 40 seconds check for potential spawn
		if (Math.random() < 0.08) {
			// 8% chance - extremely rare occurrence
			spawnCosmicBeam();
		}
	}
	// Enhanced cosmic ray spawning during core evolution events
	if (coreEvolutions > 0 && LK.ticks % 600 === 0) {
		// Every 10 seconds during evolutions
		if (Math.random() < 0.08) {
			// 8% chance for evolution-enhanced rays
			spawnCosmicRay();
		}
	}
	// Core Evolution Detection - significant milestones trigger color transitions
	var totalNodes = spireNodes.length;
	var dustLevel = Math.floor(luminaDust / 1000);
	var coreLevel = luminaCore.coreLevel;
	var clickLevel = luminaCore.clickPower;
	// Check for significant Core Evolutions (major milestones)
	var evolutionThreshold = 10000 + coreEvolutions * 15000; // Increasing thresholds
	var transcendenceThreshold = 50000 + transcendenceLevel * 100000;
	if (luminaDust >= evolutionThreshold && luminaDust > lastEvolutionCheck) {
		coreEvolutions++;
		lastEvolutionCheck = luminaDust;
		storage.coreEvolutions = coreEvolutions;
		storage.lastEvolutionCheck = lastEvolutionCheck;
		// Trigger dramatic nebula color palette shift
		triggerNebulaColorEvolution();
		LK.effects.flashScreen(0x9370db, 2000); // Purple evolution flash
		// Enhanced ethereal energy emission during evolution
		for (var i = 0; i < 8; i++) {
			// Burst of ethereal energy
			LK.setTimeout(function (index) {
				return function () {
					spawnLuminaEnergyWisp();
				};
			}(i), i * 200); // Staggered spawning over 1.6 seconds
		}
		// Enhance existing energy wisps during evolution
		for (var i = 0; i < luminaEnergyWisps.length; i++) {
			var wisp = luminaEnergyWisps[i];
			tween(wisp.children[0], {
				alpha: 0.4,
				// Brighter during evolution
				scaleX: 1.5,
				scaleY: 1.5,
				tint: 0xffd700 // Golden energy during evolution
			}, {
				duration: 3000,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					tween(wisp.children[0], {
						alpha: 0.15,
						scaleX: 0.7,
						scaleY: 0.7,
						tint: 0x9370db // Return to purple
					}, {
						duration: 2000,
						easing: tween.easeInOut
					});
				}
			});
		}
	}
	// Check for Transcendence events (ultimate transformations)
	if (luminaDust >= transcendenceThreshold && totalNodes >= 20) {
		transcendenceLevel++;
		storage.transcendenceLevel = transcendenceLevel;
		// Major cosmic transformation
		triggerCosmicTranscendence();
		LK.effects.flashScreen(0xffd700, 3000); // Golden transcendence flash
	}
	// Update cosmic color phase based on evolutions and transcendence
	var newColorPhase = Math.min(4, coreEvolutions + transcendenceLevel);
	if (newColorPhase !== currentColorPhase) {
		currentColorPhase = newColorPhase;
		storage.colorPhase = currentColorPhase;
		// Gradually shift background color based on Core's growing influence
		var backgroundColors = [0x1a0d2e,
		// Base: deep purple void
		0x221544,
		// Evolution 1: slightly warmer purple
		0x2a1d5a,
		// Evolution 2: deeper purple with warmth
		0x32256f,
		// Evolution 3: warmer purple with golden hints
		0x4a3373 // Transcendence: vibrant purple-violet
		];
		var targetBg = backgroundColors[currentColorPhase];
		tween(game, {
			backgroundColor: targetBg
		}, {
			duration: 5000,
			// Longer transition for evolution
			easing: tween.easeInOut
		});
	}
	// Create subtle temporal distortion waves that affect the entire universe
	if (LK.ticks % 2400 === 0) {
		// Every 40 seconds
		// Create temporal ripple effect that distorts space-time
		var temporalIntensity = 0.02 + Math.random() * 0.03;
		var temporalDuration = 5000 + Math.random() * 3000; // 5-8 seconds
		// Apply temporal distortion to all nebula clouds
		for (var i = 0; i < nebulaClouds.length; i++) {
			var cloud = nebulaClouds[i];
			var distortionPhase = Math.random() * Math.PI * 2;
			// Create temporal wave effect
			tween(cloud, {
				scaleX: cloud.baseScale * (1.0 + temporalIntensity),
				scaleY: cloud.baseScale * (1.0 - temporalIntensity * 0.5),
				rotation: cloud.rotation + (Math.random() - 0.5) * 0.1
			}, {
				duration: temporalDuration * 0.3,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					// Return to normal with slight variation
					tween(cloud, {
						scaleX: cloud.baseScale * (0.95 + Math.random() * 0.1),
						scaleY: cloud.baseScale * (0.95 + Math.random() * 0.1)
					}, {
						duration: temporalDuration * 0.7,
						easing: tween.easeInOut
					});
				}
			});
		}
		// Apply temporal distortion to distant stars
		for (var i = 0; i < distantStars.length; i++) {
			var star = distantStars[i];
			if (Math.random() < 0.3) {
				// Only affect 30% of stars for subtle effect
				var originalAlpha = star.children[0].alpha;
				tween(star.children[0], {
					alpha: originalAlpha * (1.5 + Math.random()),
					scaleX: 1.0 + Math.random() * 0.5,
					scaleY: 1.0 + Math.random() * 0.5
				}, {
					duration: temporalDuration * 0.4,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(star.children[0], {
							alpha: originalAlpha,
							scaleX: 0.5 + Math.random() * 0.5,
							scaleY: 0.5 + Math.random() * 0.5
						}, {
							duration: temporalDuration * 0.6,
							easing: tween.easeInOut
						});
					}
				});
			}
		}
		// Create subtle cosmic wind effect
		LK.effects.flashScreen(0x4a3373, 2000); // Very subtle purple flash
	}
	// Add cosmic energy fluctuations that create living background
	if (LK.ticks % 1800 === 0) {
		// Every 30 seconds
		// Create energy wave that affects all cosmic elements
		var energyWaveIntensity = 0.1 + Math.random() * 0.1;
		var energyDuration = 8000 + Math.random() * 4000; // 8-12 seconds
		// Apply energy fluctuation to lumina core
		tween(luminaCore.children[0], {
			tint: 0x9370db,
			// Brighter purple during energy wave
			scaleX: luminaCore.baseScale * (1.0 + energyWaveIntensity),
			scaleY: luminaCore.baseScale * (1.0 + energyWaveIntensity)
		}, {
			duration: energyDuration * 0.5,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(luminaCore.children[0], {
					tint: 0x6a5acd,
					// Return to normal
					scaleX: luminaCore.baseScale,
					scaleY: luminaCore.baseScale
				}, {
					duration: energyDuration * 0.5,
					easing: tween.easeInOut
				});
			}
		});
		// Apply energy wave to spire nodes
		for (var i = 0; i < spireNodes.length; i++) {
			var node = spireNodes[i];
			if (!node.isDecaying) {
				tween(node.children[0], {
					tint: 0x00ffff,
					// Bright cyan during energy wave
					scaleX: 1.2,
					scaleY: 1.2
				}, {
					duration: energyDuration * 0.3,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(node.children[0], {
							tint: 0xffffff,
							// Return to normal
							scaleX: 1.0,
							scaleY: 1.0
						}, {
							duration: energyDuration * 0.7,
							easing: tween.easeInOut
						});
					}
				});
			}
		}
	}
	// Add subtle reality distortion that affects space itself
	if (LK.ticks % 3600 === 0) {
		// Every 60 seconds
		// Create space-time distortion effect
		var distortionIntensity = 0.05 + Math.random() * 0.05;
		var distortionDuration = 12000 + Math.random() * 6000; // 12-18 seconds
		// Apply reality distortion to entire game space
		tween(game, {
			scaleX: 1.0 + distortionIntensity,
			scaleY: 1.0 - distortionIntensity * 0.5
		}, {
			duration: distortionDuration * 0.4,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(game, {
					scaleX: 1.0 - distortionIntensity * 0.5,
					scaleY: 1.0 + distortionIntensity * 0.3
				}, {
					duration: distortionDuration * 0.4,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(game, {
							scaleX: 1.0,
							scaleY: 1.0
						}, {
							duration: distortionDuration * 0.2,
							easing: tween.easeInOut
						});
					}
				});
			}
		});
	}
	// Save game state periodically
	if (LK.ticks % 300 === 0) {
		// Every 5 seconds
		storage.luminaDust = luminaDust;
		storage.clickPower = luminaCore.clickPower;
		storage.spireNodeCount = spireNodes.length;
		storage.colorPhase = currentColorPhase;
	}
};