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

/**** 
* Classes
****/ 
var Building = Container.expand(function (buildingX, buildingY, scale, height) {
	var self = Container.call(this);
	// Building base with varying heights
	var baseHeight = height || Math.random() * 200 + 250;
	var buildingBase = self.attachAsset('building_base', {
		anchorX: 0.5,
		anchorY: 1
	});
	buildingBase.scaleY = baseHeight / 300;
	buildingBase.y = 0;
	// Building roof
	var roof = self.attachAsset('building_roof', {
		anchorX: 0.5,
		anchorY: 1
	});
	roof.y = -baseHeight;
	// Add windows in a grid pattern
	var windowRows = Math.floor(baseHeight / 40);
	var windowCols = 4;
	for (var row = 0; row < windowRows; row++) {
		for (var col = 0; col < windowCols; col++) {
			var window = self.attachAsset('building_window', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			window.x = (col - 1.5) * 25;
			window.y = -30 - row * 40;
			// Random window lighting
			if (Math.random() > 0.3) {
				window.alpha = Math.random() * 0.8 + 0.2;
			} else {
				window.alpha = 0.1;
			}
		}
	}
	// Set position and scale
	self.x = buildingX;
	self.y = buildingY;
	self.scaleX = scale || 1;
	self.scaleY = scale || 1;
	// Animation properties for subtle building sway
	self.swaySpeed = Math.random() * 0.005 + 0.002;
	self.swayAmount = Math.random() * 0.02 + 0.01;
	self.animationOffset = Math.random() * Math.PI * 2;
	self.update = function () {
		// Very subtle building sway
		var sway = Math.sin(LK.ticks * self.swaySpeed + self.animationOffset) * self.swayAmount;
		self.rotation = sway;
	};
	return self;
});
var Cloud = Container.expand(function (cloudX, cloudY, cloudScale) {
	var self = Container.call(this);
	// Create cloud with multiple overlapping circles
	var cloud1 = self.attachAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var cloud2 = self.attachAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	cloud2.x = 40;
	cloud2.scaleX = 0.8;
	cloud2.scaleY = 0.8;
	var cloud3 = self.attachAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	cloud3.x = -30;
	cloud3.scaleX = 0.9;
	cloud3.scaleY = 0.9;
	self.x = cloudX;
	self.y = cloudY;
	self.scaleX = cloudScale || 1;
	self.scaleY = cloudScale || 1;
	// Floating animation
	self.floatSpeed = Math.random() * 0.01 + 0.005;
	self.floatAmount = Math.random() * 20 + 10;
	self.driftSpeed = Math.random() * 0.5 + 0.2;
	self.originalX = cloudX;
	self.update = function () {
		// Gentle floating motion
		self.y = cloudY + Math.sin(LK.ticks * self.floatSpeed) * self.floatAmount;
		// Slow horizontal drift
		self.x += self.driftSpeed;
		// Reset position when off screen
		if (self.x > 2200) {
			self.x = -200;
		}
	};
	return self;
});
var Fruit = Container.expand(function (fruitType) {
	var self = Container.call(this);
	self.fruitType = fruitType;
	self.sliced = false;
	self.fallSpeed = Math.random() * 3 + (baseFallSpeed + currentDifficultyLevel * 0.3);
	var fruitGraphics = self.attachAsset(fruitType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set initial random horizontal velocity
	self.velocityX = (Math.random() - 0.5) * 4;
	self.velocityY = self.fallSpeed;
	self.gravity = 0.1;
	self.update = function () {
		if (!self.sliced) {
			self.x += self.velocityX;
			self.y += self.velocityY;
			self.velocityY += self.gravity;
		}
	};
	self.slice = function () {
		if (self.sliced) return;
		self.sliced = true;
		// Award points based on fruit type
		var points = 0;
		switch (self.fruitType) {
			case 'apple':
				points = 10;
				break;
			case 'orange':
				points = 15;
				break;
			case 'watermelon':
				points = 30;
				break;
			case 'pineapple':
				points = 25;
				break;
			case 'banana':
				points = 20;
				break;
		}
		LK.setScore(LK.getScore() + points);
		updateScoreDisplay(LK.getScore());
		// Update difficulty progressively based on score
		var newScore = LK.getScore();
		var newDifficultyLevel = Math.floor(newScore / 50); // Increase difficulty every 50 points
		if (newDifficultyLevel > currentDifficultyLevel) {
			currentDifficultyLevel = newDifficultyLevel;
			// Gradually decrease spawn rate (faster spawning) - minimum 20 frames
			spawnRate = Math.max(20, baseSpawnRate - currentDifficultyLevel * 8);
		}
		// Create slice effect
		self.createSliceEffect();
		// Play slice sound
		LK.getSound('slice').play();
		// Create floating score text
		var floatingScore = new Text2('+' + points, {
			size: 60,
			fill: 0xFFD700
		});
		floatingScore.anchor.set(0.5, 0.5);
		floatingScore.x = self.x;
		floatingScore.y = self.y;
		game.addChild(floatingScore);
		// Animate floating score
		tween(floatingScore, {
			y: floatingScore.y - 150,
			alpha: 0
		}, {
			duration: 1000,
			onComplete: function onComplete() {
				floatingScore.destroy();
			}
		});
		// Animate fruit halves
		self.animateSlice();
	};
	self.createSliceEffect = function () {
		// Create particle explosion
		for (var i = 0; i < 8; i++) {
			var particle = new Particle();
			particle.x = self.x;
			particle.y = self.y;
			particles.push(particle);
			game.addChild(particle);
		}
	};
	self.animateSlice = function () {
		// Split fruit into two halves
		var leftHalf = self.attachAsset(self.fruitType, {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -20
		});
		var rightHalf = self.attachAsset(self.fruitType, {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 20
		});
		// Hide original fruit
		fruitGraphics.alpha = 0;
		// Animate halves falling
		tween(leftHalf, {
			x: leftHalf.x - 100,
			y: leftHalf.y + 200,
			rotation: -1
		}, {
			duration: 1000
		});
		tween(rightHalf, {
			x: rightHalf.x + 100,
			y: rightHalf.y + 200,
			rotation: 1
		}, {
			duration: 1000
		});
		tween(leftHalf, {
			alpha: 0
		}, {
			duration: 800
		});
		tween(rightHalf, {
			alpha: 0
		}, {
			duration: 800
		});
	};
	return self;
});
var GrassClump = Container.expand(function (grassX, grassY) {
	var self = Container.call(this);
	// Create multiple grass blades
	for (var i = 0; i < 5; i++) {
		var blade = self.attachAsset('grass_blade', {
			anchorX: 0.5,
			anchorY: 1
		});
		blade.x = (i - 2) * 8;
		blade.scaleY = Math.random() * 0.5 + 0.7;
		blade.rotation = (Math.random() - 0.5) * 0.3;
		// Vary grass color slightly
		var greenVariation = Math.random() * 0.2 + 0.9;
		blade.tint = 0x7CFC00 * greenVariation;
	}
	self.x = grassX;
	self.y = grassY;
	// Wind animation
	self.windSpeed = Math.random() * 0.03 + 0.02;
	self.windOffset = Math.random() * Math.PI * 2;
	self.update = function () {
		var wind = Math.sin(LK.ticks * self.windSpeed + self.windOffset) * 0.15;
		self.rotation = wind;
	};
	return self;
});
var Katana = Container.expand(function () {
	var self = Container.call(this);
	self.trailPoints = [];
	self.maxTrailLength = 10;
	var katanaGraphics = self.attachAsset('katana', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.updatePosition = function (x, y) {
		// Add current position to trail
		self.trailPoints.push({
			x: self.x,
			y: self.y
		});
		if (self.trailPoints.length > self.maxTrailLength) {
			self.trailPoints.shift();
		}
		// Calculate angle based on movement
		if (self.trailPoints.length > 1) {
			var lastPoint = self.trailPoints[self.trailPoints.length - 2];
			var angle = Math.atan2(y - lastPoint.y, x - lastPoint.x);
			katanaGraphics.rotation = angle;
		}
		self.x = x;
		self.y = y;
	};
	self.checkFruitCollisions = function () {
		for (var i = fruits.length - 1; i >= 0; i--) {
			var fruit = fruits[i];
			if (!fruit.sliced && self.intersects(fruit)) {
				fruit.slice();
			}
		}
	};
	return self;
});
var Particle = Container.expand(function () {
	var self = Container.call(this);
	var particleGraphics = self.attachAsset('particle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = (Math.random() - 0.5) * 10;
	self.velocityY = (Math.random() - 0.5) * 10;
	self.life = 60; // 1 second at 60fps
	// Random color for juice effect
	var colors = [0xFF6B6B, 0xFFE66D, 0x4ECDC4, 0x45B7D1, 0x96CEB4];
	particleGraphics.tint = colors[Math.floor(Math.random() * colors.length)];
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		self.velocityY += 0.2; // gravity
		self.life--;
		particleGraphics.alpha = self.life / 60;
		if (self.life <= 0) {
			self.destroy();
			for (var i = particles.length - 1; i >= 0; i--) {
				if (particles[i] === self) {
					particles.splice(i, 1);
					break;
				}
			}
		}
	};
	return self;
});
var ShootingStar = Container.expand(function (startX, startY) {
	var self = Container.call(this);
	// Create main shooting star body
	var starBody = self.attachAsset('particle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	starBody.tint = 0xFFFFFF;
	starBody.scaleX = 1.5;
	starBody.scaleY = 1.5;
	// Create glowing trail particles
	self.trailParticles = [];
	for (var t = 0; t < 8; t++) {
		var trailParticle = self.attachAsset('particle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		trailParticle.tint = 0xFFD700; // Golden trail
		trailParticle.scaleX = 0.8 - t * 0.1;
		trailParticle.scaleY = 0.8 - t * 0.1;
		trailParticle.alpha = 0.8 - t * 0.1;
		self.trailParticles.push(trailParticle);
	}
	// Set position and movement properties
	self.x = startX;
	self.y = startY;
	self.velocityX = Math.random() * 3 + 2; // Moving right and down
	self.velocityY = Math.random() * 4 + 3;
	self.life = 300; // 5 seconds at 60fps
	self.maxLife = 300;
	// Trail position tracking
	self.trailPositions = [];
	self.update = function () {
		// Store current position for trail
		self.trailPositions.push({
			x: self.x,
			y: self.y
		});
		if (self.trailPositions.length > self.trailParticles.length) {
			self.trailPositions.shift();
		}
		// Update position
		self.x += self.velocityX;
		self.y += self.velocityY;
		self.life--;
		// Update trail particles
		for (var t = 0; t < self.trailParticles.length; t++) {
			if (self.trailPositions[self.trailPositions.length - 1 - t]) {
				var trailPos = self.trailPositions[self.trailPositions.length - 1 - t];
				self.trailParticles[t].x = trailPos.x - self.x;
				self.trailParticles[t].y = trailPos.y - self.y;
			}
		}
		// Fade out as life decreases
		var fadePercent = self.life / self.maxLife;
		starBody.alpha = fadePercent;
		for (var t = 0; t < self.trailParticles.length; t++) {
			self.trailParticles[t].alpha = (0.8 - t * 0.1) * fadePercent;
		}
		// Twinkle effect
		starBody.scaleX = 1.5 + Math.sin(LK.ticks * 0.2) * 0.3;
		starBody.scaleY = 1.5 + Math.sin(LK.ticks * 0.2) * 0.3;
	};
	return self;
});
var Tree = Container.expand(function (treeX, treeY, scale) {
	var self = Container.call(this);
	// Tree trunk
	var trunk = self.attachAsset('tree_trunk', {
		anchorX: 0.5,
		anchorY: 1
	});
	trunk.y = 0;
	// Multiple foliage layers for depth
	var foliageDark = self.attachAsset('tree_foliage_dark', {
		anchorX: 0.5,
		anchorY: 1
	});
	foliageDark.y = -200;
	foliageDark.x = 10;
	var foliageMain = self.attachAsset('tree_foliage', {
		anchorX: 0.5,
		anchorY: 1
	});
	foliageMain.y = -180;
	var foliageLight = self.attachAsset('tree_foliage_light', {
		anchorX: 0.5,
		anchorY: 1
	});
	foliageLight.y = -160;
	foliageLight.x = -15;
	// Set position and scale
	self.x = treeX;
	self.y = treeY;
	self.scaleX = scale || 1;
	self.scaleY = scale || 1;
	// Animation properties
	self.swaySpeed = Math.random() * 0.02 + 0.01;
	self.swayAmount = Math.random() * 0.1 + 0.05;
	self.animationOffset = Math.random() * Math.PI * 2;
	self.update = function () {
		// Gentle swaying animation
		var sway = Math.sin(LK.ticks * self.swaySpeed + self.animationOffset) * self.swayAmount;
		foliageMain.rotation = sway;
		foliageLight.rotation = sway * 0.8;
		foliageDark.rotation = sway * 1.2;
		trunk.rotation = sway * 0.3;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Create animated forest background
var backgroundContainer = new Container();
game.addChild(backgroundContainer);
// Create sky gradient effect with sunset to night colors
var skyLayers = [];
var sunsetColors = [0xFF6B35,
// Bright orange at horizon
0xFF8C42,
// Orange-red
0xE74C3C,
// Deep red
0x8E44AD,
// Purple
0x2C3E50,
// Dark blue-purple
0x1B2631,
// Very dark blue
0x17202A,
// Near black
0x0B1426 // Deep night
];
for (var s = 0; s < 8; s++) {
	var skyLayer = LK.getAsset('shape', {
		anchorX: 0,
		anchorY: 0,
		scaleX: 20.48,
		scaleY: 3.4
	});
	skyLayer.y = s * 340;
	// Use sunset to night gradient colors
	skyLayer.tint = sunsetColors[s];
	skyLayer.alpha = 0.8;
	backgroundContainer.addChild(skyLayer);
	skyLayers.push(skyLayer);
}
;
// Play ambient music for game atmosphere
LK.playMusic('Ambiente', {
	loop: true
});
// Create sun with sunset colors
var sun = backgroundContainer.addChild(LK.getAsset('sun', {
	anchorX: 0.5,
	anchorY: 0.5
}));
sun.x = 1600;
sun.y = 400; // Lower position for sunset effect
sun.tint = 0xFF4500; // Orange-red sunset color
sun.scaleX = 1.3;
sun.scaleY = 1.3;
// Create flat moon as simple circle without relief
var moon = backgroundContainer.addChild(LK.getAsset('moon_circle', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 1.2,
	scaleY: 1.2
}));
moon.x = 500;
moon.y = 350;
moon.alpha = 1.0; // Full opacity, no shadow effect
moon.tint = 0xF8F8FF; // Keep moon white, unaffected by sky changes
// Create yellow aura glow around moon
var moonGlow = backgroundContainer.addChild(LK.getAsset('moon_circle', {
	anchorX: 0.5,
	anchorY: 0.5
}));
moonGlow.x = 500;
moonGlow.y = 350;
moonGlow.tint = 0xFFFF00; // Yellow aura color
moonGlow.alpha = 0.3;
moonGlow.scaleX = 2.0; // Larger than moon for glow effect
moonGlow.scaleY = 2.0;
// Animate moon glow with pulsing effect
tween(moonGlow, {
	scaleX: 2.5,
	scaleY: 2.5,
	alpha: 0.1
}, {
	duration: 3000,
	onComplete: function onComplete() {
		tween(moonGlow, {
			scaleX: 2.0,
			scaleY: 2.0,
			alpha: 0.3
		}, {
			duration: 3000
		});
	}
});
// Animate sun with warm sunset glow
var sunGlow = backgroundContainer.addChild(LK.getAsset('sun', {
	anchorX: 0.5,
	anchorY: 0.5
}));
sunGlow.x = 1600;
sunGlow.y = 400;
sunGlow.tint = 0xFF6B35; // Warm orange glow
sunGlow.alpha = 0.4;
sunGlow.scaleX = 2.0;
sunGlow.scaleY = 2.0;
// Create layered mountains with anime-style atmospheric perspective and snow caps
var mountains = [];
var snowCaps = [];
// Far distant snow-capped mountains (very light blue/purple with white peaks)
for (var m1 = 0; m1 < 8; m1++) {
	var farMountain = backgroundContainer.addChild(LK.getAsset('mountain', {
		anchorX: 0.5,
		anchorY: 1
	}));
	farMountain.x = m1 * 350 + 100;
	farMountain.y = 1800;
	farMountain.scaleY = Math.random() * 0.3 + 0.4;
	farMountain.scaleX = Math.random() * 0.4 + 0.8;
	farMountain.tint = 0x9BB5D6; // Light blue-purple
	farMountain.alpha = 0.4;
	mountains.push(farMountain);
	// Add snow cap to tall mountains
	if (farMountain.scaleY > 0.6) {
		var farSnowCap = backgroundContainer.addChild(LK.getAsset('snow_cap', {
			anchorX: 0.5,
			anchorY: 1
		}));
		farSnowCap.x = farMountain.x;
		farSnowCap.y = farMountain.y - farMountain.scaleY * 200 * 0.7;
		farSnowCap.scaleX = farMountain.scaleX * 0.9;
		farSnowCap.scaleY = 0.3;
		farSnowCap.alpha = 0.6;
		farSnowCap.tint = 0xf0f8ff;
		snowCaps.push(farSnowCap);
	}
}
// Mid-distance snow-capped mountains (blue-gray with prominent snow)
for (var m2 = 0; m2 < 6; m2++) {
	var midMountain = backgroundContainer.addChild(LK.getAsset('mountain', {
		anchorX: 0.5,
		anchorY: 1
	}));
	midMountain.x = m2 * 400 + 150;
	midMountain.y = 2000;
	midMountain.scaleY = Math.random() * 0.4 + 0.6;
	midMountain.scaleX = Math.random() * 0.3 + 0.9;
	midMountain.tint = 0x7A8FA3; // Blue-gray
	midMountain.alpha = 0.6;
	mountains.push(midMountain);
	// Add snow cap
	var midSnowCap = backgroundContainer.addChild(LK.getAsset('snow_cap', {
		anchorX: 0.5,
		anchorY: 1
	}));
	midSnowCap.x = midMountain.x;
	midSnowCap.y = midMountain.y - midMountain.scaleY * 200 * 0.6;
	midSnowCap.scaleX = midMountain.scaleX * 0.95;
	midSnowCap.scaleY = 0.4;
	midSnowCap.alpha = 0.8;
	snowCaps.push(midSnowCap);
}
// Close mountains (green-brown)
for (var m3 = 0; m3 < 4; m3++) {
	var closeMountain = backgroundContainer.addChild(LK.getAsset('mountain', {
		anchorX: 0.5,
		anchorY: 1
	}));
	closeMountain.x = m3 * 500 + 200;
	closeMountain.y = 2200;
	closeMountain.scaleY = Math.random() * 0.5 + 0.8;
	closeMountain.scaleX = Math.random() * 0.3 + 1.1;
	closeMountain.tint = 0x556B2F;
	closeMountain.alpha = 0.8;
	mountains.push(closeMountain);
}
// Add distant city buildings behind mountains
var distantBuildings = [];
for (var db = 0; db < 12; db++) {
	var building = backgroundContainer.addChild(new Building(db * 180 + Math.random() * 50 + 50, 1900, Math.random() * 0.4 + 0.3, Math.random() * 150 + 200));
	building.alpha = 0.3;
	building.tint = 0x708090;
	distantBuildings.push(building);
}
// Add mid-distance city buildings
var midBuildings = [];
for (var mb = 0; mb < 8; mb++) {
	var midBuilding = backgroundContainer.addChild(new Building(mb * 250 + Math.random() * 80 + 100, 2100, Math.random() * 0.3 + 0.5, Math.random() * 200 + 300));
	midBuilding.alpha = 0.5;
	midBuilding.tint = 0x556B6F;
	midBuildings.push(midBuilding);
}
// Create atmospheric mist layers
var mistLayers = [];
for (var mist = 0; mist < 5; mist++) {
	var mistLayer = backgroundContainer.addChild(LK.getAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	mistLayer.x = Math.random() * 2400 - 200;
	mistLayer.y = 1600 + mist * 150;
	mistLayer.scaleX = Math.random() * 3 + 2;
	mistLayer.scaleY = Math.random() * 0.8 + 0.4;
	mistLayer.tint = 0xF0F8FF;
	mistLayer.alpha = 0.3;
	mistLayers.push(mistLayer);
}
// Create clouds
var clouds = [];
for (var c = 0; c < 8; c++) {
	var cloud = backgroundContainer.addChild(new Cloud(Math.random() * 2400 - 200, Math.random() * 600 + 200, Math.random() * 0.8 + 0.6));
	clouds.push(cloud);
}
// Create rolling hills for terrain depth
var hills = [];
for (var h = 0; h < 12; h++) {
	var hill = backgroundContainer.addChild(LK.getAsset('mountain', {
		anchorX: 0.5,
		anchorY: 1
	}));
	hill.x = h * 200 + Math.random() * 100;
	hill.y = 2300 + Math.random() * 100;
	hill.scaleY = Math.random() * 0.3 + 0.2;
	hill.scaleX = Math.random() * 0.5 + 1.5;
	hill.tint = 0x6B8E23; // Olive green
	hill.alpha = 0.6;
	hills.push(hill);
}
// Create background trees (larger, further back)
var backgroundTrees = [];
for (var bt = 0; bt < 15; bt++) {
	var bgTree = backgroundContainer.addChild(new Tree(Math.random() * 2400 - 200, 2200, Math.random() * 0.8 + 1.2));
	bgTree.alpha = 0.7;
	bgTree.tint = 0x556B2F;
	backgroundTrees.push(bgTree);
}
// Create middle ground trees
var middleTrees = [];
for (var mt = 0; mt < 20; mt++) {
	var midTree = backgroundContainer.addChild(new Tree(Math.random() * 2600 - 300, 2400, Math.random() * 0.6 + 0.8));
	midTree.alpha = 0.85;
	middleTrees.push(midTree);
}
// Create foreground trees
var foregroundTrees = [];
for (var ft = 0; ft < 12; ft++) {
	var fgTree = backgroundContainer.addChild(new Tree(Math.random() * 2800 - 400, 2600, Math.random() * 0.4 + 0.6));
	foregroundTrees.push(fgTree);
}
// Create grass clumps across the ground
var grassClumps = [];
for (var g = 0; g < 50; g++) {
	var grass = backgroundContainer.addChild(new GrassClump(Math.random() * 2400, 2650 + Math.random() * 80));
	grassClumps.push(grass);
}
// Create cherry blossom petals floating in the air
var blossomPetals = [];
for (var bp = 0; bp < 25; bp++) {
	var petal = backgroundContainer.addChild(LK.getAsset('flower', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	petal.x = Math.random() * 2048;
	petal.y = Math.random() * 2000;
	petal.scaleX = Math.random() * 0.3 + 0.2;
	petal.scaleY = Math.random() * 0.3 + 0.2;
	petal.tint = 0xFFB6C1; // Light pink
	petal.alpha = Math.random() * 0.6 + 0.4;
	petal.rotation = Math.random() * Math.PI * 2;
	blossomPetals.push(petal);
}
// Create colorful flowers scattered around
var flowers = [];
var flowerColors = [0xFF69B4, 0xFF6347, 0x9370DB, 0x00CED1, 0xFFD700, 0xFF4500];
for (var f = 0; f < 30; f++) {
	var flower = backgroundContainer.addChild(LK.getAsset('flower', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	flower.x = Math.random() * 2048;
	flower.y = 2600 + Math.random() * 100;
	flower.tint = flowerColors[Math.floor(Math.random() * flowerColors.length)];
	flowers.push(flower);
}
// Create shooting stars array
var shootingStars = [];
var shootingStarSpawnTimer = 0;
var shootingStarSpawnRate = 180; // Spawn every 3 seconds (180 frames at 60fps)
// Animate sunset sun glow with warmer, more dramatic effect
tween(sunGlow, {
	scaleX: 2.8,
	scaleY: 2.8,
	alpha: 0.2
}, {
	duration: 4000,
	onComplete: function onComplete() {
		tween(sunGlow, {
			scaleX: 2.0,
			scaleY: 2.0,
			alpha: 0.4
		}, {
			duration: 4000
		});
	}
});
var fruits = [];
var particles = [];
var fruitTypes = ['apple', 'orange', 'watermelon', 'pineapple', 'banana'];
var spawnTimer = 0;
var spawnRate = 90; // frames between spawns
var baseSpawnRate = 90; // original spawn rate
var baseFallSpeed = 2; // base fall speed for fruits
var currentDifficultyLevel = 0;
// Katana health system variables
var katanaHealth = 100;
var maxKatanaHealth = 100;
var katanaParalyzed = false;
var paralyzeTimer = 0;
var lastKatanaX = 0;
var lastKatanaY = 0;
var movementSamples = [];
var maxMovementSamples = 10;
// Power-up system variables
var powerUpActive = false;
var extraKatanas = [];
var powerUpActivated = false;
// Create katana
var katana = game.addChild(new Katana());
katana.x = 1024;
katana.y = 1366;
// Game state management
var gameState = 'start'; // 'start', 'playing'
var startScreenVisible = true;
// Create new score display positioned at bottom right
var scoreContainer = new Container();
LK.gui.bottomRight.addChild(scoreContainer);
// Create shadow for depth
var scoreShadow = new Text2('0', {
	size: 80,
	fill: 0x000000
});
scoreShadow.anchor.set(1, 1);
scoreShadow.x = 2;
scoreShadow.y = 2;
scoreShadow.alpha = 0.5;
scoreContainer.addChild(scoreShadow);
// Create main score text
var scoreTxt = new Text2('0', {
	size: 80,
	fill: 0xFFD700
});
scoreTxt.anchor.set(1, 1);
scoreContainer.addChild(scoreTxt);
// Position container at bottom right with some padding
scoreContainer.x = -20; // 20px from right edge
scoreContainer.y = -20; // 20px from bottom edge
// Hide game UI on start screen
scoreContainer.visible = false;
// Create katana health bar
var healthBarContainer = new Container();
LK.gui.bottom.addChild(healthBarContainer);
// Health bar background
var healthBarBg = LK.getAsset('shape', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 3,
	scaleY: 0.3
});
healthBarBg.tint = 0x333333;
healthBarContainer.addChild(healthBarBg);
// Health bar fill
var healthBarFill = LK.getAsset('shape', {
	anchorX: 0,
	anchorY: 0.5,
	scaleX: 3,
	scaleY: 0.25
});
healthBarFill.tint = 0x27AE60;
healthBarFill.x = -150; // Start from left edge of background
healthBarContainer.addChild(healthBarFill);
// Health bar border
var healthBarBorder = LK.getAsset('shape', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 3.1,
	scaleY: 0.35
});
healthBarBorder.tint = 0xFFFFFF;
healthBarBorder.alpha = 0.8;
healthBarContainer.addChild(healthBarBorder);
// Position health bar at bottom center
healthBarContainer.x = 1024;
healthBarContainer.y = 2600;
healthBarContainer.alpha = 0; // Initially hidden
healthBarContainer.visible = false; // Hide on start screen
// Create katana power-up progress bar
var powerBarContainer = new Container();
LK.gui.topRight.addChild(powerBarContainer);
// Power bar background
var powerBarBg = LK.getAsset('shape', {
	anchorX: 1,
	anchorY: 0,
	scaleX: 2.5,
	scaleY: 0.4
});
powerBarBg.tint = 0x333333;
powerBarContainer.addChild(powerBarBg);
// Power bar fill
var powerBarFill = LK.getAsset('shape', {
	anchorX: 0,
	anchorY: 0,
	scaleX: 0,
	scaleY: 0.35
});
powerBarFill.tint = 0xFFD700; // Gold color for ninja power
powerBarFill.x = -250; // Start from left edge of background
powerBarContainer.addChild(powerBarFill);
// Power bar label
var powerBarLabel = new Text2('KATANA-NINJA', {
	size: 30,
	fill: 0xFFD700
});
powerBarLabel.anchor.set(1, 0);
powerBarLabel.x = 0;
powerBarLabel.y = -35;
powerBarContainer.addChild(powerBarLabel);
// Position power bar at top right with padding
powerBarContainer.x = -20; // 20px from right edge
powerBarContainer.y = 120; // Below the platform menu area
powerBarContainer.visible = false; // Hide on start screen
// Create new menu system from scratch
var gamePaused = false; // Add game pause state variable
var menuButtonContainer = new Container();
LK.gui.bottomLeft.addChild(menuButtonContainer);
// Create menu button background
var menuBg = LK.getAsset('shape', {
	anchorX: 0,
	anchorY: 1,
	scaleX: 2,
	scaleY: 1
});
menuBg.tint = 0x34495E;
menuBg.alpha = 0.9;
menuButtonContainer.addChild(menuBg);
// Create menu button text
var menuText = new Text2('MENU', {
	size: 50,
	fill: 0xFFFFFF
});
menuText.anchor.set(0.5, 0.5);
menuText.x = 100;
menuText.y = -50;
menuButtonContainer.addChild(menuText);
// Position menu button
menuButtonContainer.x = 20;
menuButtonContainer.y = -20;
menuButtonContainer.visible = false; // Hide on start screen
// Create game menu container
var gameMenuContainer = new Container();
gameMenuContainer.visible = false;
LK.gui.center.addChild(gameMenuContainer);
// Create dark overlay
var overlay = LK.getAsset('shape', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 25,
	scaleY: 35
});
overlay.tint = 0x000000;
overlay.alpha = 0.8;
gameMenuContainer.addChild(overlay);
// Create menu panel
var menuPanel = LK.getAsset('shape', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 8,
	scaleY: 10
});
menuPanel.tint = 0x2C3E50;
menuPanel.alpha = 0.95;
gameMenuContainer.addChild(menuPanel);
// Create menu title
var menuTitle = new Text2('MENU', {
	size: 80,
	fill: 0xE74C3C
});
menuTitle.anchor.set(0.5, 0.5);
menuTitle.y = -300;
gameMenuContainer.addChild(menuTitle);
// Create continue button
var continueBtn = LK.getAsset('shape', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 5,
	scaleY: 1.5
});
continueBtn.tint = 0x27AE60;
continueBtn.y = -100;
gameMenuContainer.addChild(continueBtn);
var continueText = new Text2('CONTINUAR', {
	size: 55,
	fill: 0xFFFFFF
});
continueText.anchor.set(0.5, 0.5);
continueText.y = -100;
gameMenuContainer.addChild(continueText);
// Create restart button
var restartBtn = LK.getAsset('shape', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 5,
	scaleY: 1.5
});
restartBtn.tint = 0xF39C12;
restartBtn.y = 50;
gameMenuContainer.addChild(restartBtn);
var restartText = new Text2('REINICIAR', {
	size: 55,
	fill: 0xFFFFFF
});
restartText.anchor.set(0.5, 0.5);
restartText.y = 50;
gameMenuContainer.addChild(restartText);
// Create exit button
var exitBtn = LK.getAsset('shape', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 5,
	scaleY: 1.5
});
exitBtn.tint = 0xE74C3C;
exitBtn.y = 200;
gameMenuContainer.addChild(exitBtn);
var exitText = new Text2('SALIR', {
	size: 55,
	fill: 0xFFFFFF
});
exitText.anchor.set(0.5, 0.5);
exitText.y = 200;
gameMenuContainer.addChild(exitText);
// Menu button interaction
menuButtonContainer.down = function (x, y, obj) {
	// Pause the game
	gamePaused = true;
	// Show menu (game will be paused by checking gamePaused in update)
	gameMenuContainer.visible = true;
	gameMenuContainer.alpha = 0;
	gameMenuContainer.scaleX = 0.7;
	gameMenuContainer.scaleY = 0.7;
	tween(gameMenuContainer, {
		alpha: 1,
		scaleX: 1,
		scaleY: 1
	}, {
		duration: 250
	});
};
// Continue button interaction
continueBtn.down = function (x, y, obj) {
	tween(gameMenuContainer, {
		alpha: 0,
		scaleX: 0.7,
		scaleY: 0.7
	}, {
		duration: 200,
		onComplete: function onComplete() {
			gameMenuContainer.visible = false;
			// Resume the game
			gamePaused = false;
			// Reset spawn timer to ensure fruits start falling again
			spawnTimer = 0;
		}
	});
};
// Restart button interaction
restartBtn.down = function (x, y, obj) {
	LK.showGameOver();
};
// Exit button interaction
exitBtn.down = function (x, y, obj) {
	// Return to start screen
	gameState = 'start';
	startScreenVisible = true;
	// Hide game UI elements
	scoreContainer.visible = false;
	healthBarContainer.visible = false;
	powerBarContainer.visible = false;
	menuButtonContainer.visible = false;
	// Hide menu
	gameMenuContainer.visible = false;
	gamePaused = false;
	// Show start screen
	startScreenContainer.visible = true;
	startScreenContainer.alpha = 1;
	startScreenContainer.scaleX = 1;
	startScreenContainer.scaleY = 1;
};
// Create start screen container
var startScreenContainer = new Container();
game.addChild(startScreenContainer);
// Create start screen dark overlay
var startOverlay = LK.getAsset('shape', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 25,
	scaleY: 35
});
startOverlay.tint = 0x000000;
startOverlay.alpha = 0.6;
startOverlay.x = 1024;
startOverlay.y = 1366;
startScreenContainer.addChild(startOverlay);
// Create main title
var gameTitle = new Text2('FRUIT NINJA', {
	size: 120,
	fill: 0xE74C3C
});
gameTitle.anchor.set(0.5, 0.5);
gameTitle.x = 1024;
gameTitle.y = 800;
startScreenContainer.addChild(gameTitle);
// Create subtitle
var gameSubtitle = new Text2('KATANA MASTER', {
	size: 60,
	fill: 0xFFD700
});
gameSubtitle.anchor.set(0.5, 0.5);
gameSubtitle.x = 1024;
gameSubtitle.y = 950;
startScreenContainer.addChild(gameSubtitle);
// Create play button
var playBtn = LK.getAsset('shape', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 6,
	scaleY: 2
});
playBtn.tint = 0x27AE60;
playBtn.x = 1024;
playBtn.y = 1200;
startScreenContainer.addChild(playBtn);
var playText = new Text2('JUGAR', {
	size: 70,
	fill: 0xFFFFFF
});
playText.anchor.set(0.5, 0.5);
playText.x = 1024;
playText.y = 1200;
startScreenContainer.addChild(playText);
// Create instructions
var instructionText = new Text2('Desliza para cortar frutas\nEvita que toquen el suelo', {
	size: 50,
	fill: 0xFFFFFF
});
instructionText.anchor.set(0.5, 0.5);
instructionText.x = 1024;
instructionText.y = 1500;
startScreenContainer.addChild(instructionText);
// Play button interaction
playBtn.down = function (x, y, obj) {
	// Start the game
	gameState = 'playing';
	startScreenVisible = false;
	// Show game UI elements
	scoreContainer.visible = true;
	healthBarContainer.visible = true;
	powerBarContainer.visible = true;
	menuButtonContainer.visible = true;
	// Animate start screen out
	tween(startScreenContainer, {
		alpha: 0,
		scaleX: 0.8,
		scaleY: 0.8
	}, {
		duration: 500,
		onComplete: function onComplete() {
			startScreenContainer.visible = false;
		}
	});
};
// Play button hover effect
playBtn.move = function (x, y, obj) {
	playBtn.alpha = 0.8;
};
// Button hover effects
continueBtn.move = function (x, y, obj) {
	continueBtn.alpha = 0.8;
};
restartBtn.move = function (x, y, obj) {
	restartBtn.alpha = 0.8;
};
exitBtn.move = function (x, y, obj) {
	exitBtn.alpha = 0.8;
};
menuButtonContainer.move = function (x, y, obj) {
	menuBg.alpha = 0.7;
};
// Function to update all score texts and add animation
function updateScoreDisplay(newScore) {
	var scoreText = newScore.toString();
	scoreTxt.setText(scoreText);
	scoreShadow.setText(scoreText);
	// Add pulsing animation
	tween(scoreContainer, {
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 150,
		onComplete: function onComplete() {
			tween(scoreContainer, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 150
			});
		}
	});
	// Update power bar progress (power activates at 5200, not 6000)
	var powerProgress = Math.min(newScore / 5200, 1.0); // Progress from 0 to 1
	var powerBarWidth = 2.5 * powerProgress; // Scale to match background width
	tween(powerBarFill, {
		scaleX: powerBarWidth
	}, {
		duration: 200
	});
	// Change power bar color as it fills up
	if (powerProgress >= 1.0) {
		powerBarFill.tint = 0x00FF00; // Green when ready
		powerBarLabel.setText('READY!');
	} else if (powerProgress >= 0.7) {
		powerBarFill.tint = 0xFFD700; // Gold when close
	} else {
		powerBarFill.tint = 0xFF6B35; // Orange when building up
	}
	// Check for power-up activation at 5200 score (changed from 6000)
	if (newScore >= 5200 && !powerUpActivated) {
		activatePowerUp();
		powerUpActivated = true;
	}
	// Enhanced color change effect based on score
	if (newScore >= 5200) {
		scoreTxt.fill = 0xFFD700; // Gold for power-up scores
	} else if (newScore >= 500) {
		scoreTxt.fill = 0xE74C3C; // Red for high scores
	} else if (newScore >= 200) {
		scoreTxt.fill = 0x9B59B6; // Purple for medium scores
	} else if (newScore >= 100) {
		scoreTxt.fill = 0x3498DB; // Blue for decent scores
	} else {
		scoreTxt.fill = 0xFFD700; // Gold for starting scores
	}
}
// Power-up activation function
function activatePowerUp() {
	powerUpActive = true;
	// Create visual explosion effect
	LK.effects.flashScreen(0xFFD700, 2000); // Golden flash
	// Create additional katanas
	for (var k = 0; k < 2; k++) {
		var extraKatana = game.addChild(new Katana());
		extraKatana.x = katana.x;
		extraKatana.y = katana.y;
		extraKatanas.push(extraKatana);
		// Add golden tint to extra katanas
		extraKatana.tint = 0xFFD700;
		// Add glowing effect to extra katanas
		tween(extraKatana, {
			alpha: 0.7
		}, {
			duration: 500,
			onComplete: function onComplete() {
				tween(extraKatana, {
					alpha: 1
				}, {
					duration: 500
				});
			}
		});
	}
	// Add golden glow effect to main katana
	katana.tint = 0xFFD700;
	tween(katana, {
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 300,
		onComplete: function onComplete() {
			tween(katana, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 300
			});
		}
	});
}
// Track mouse movement
var isSlicing = false;
var lastMouseX = 0;
var lastMouseY = 0;
game.move = function (x, y, obj) {
	if (!katanaParalyzed) {
		katana.updatePosition(x, y);
		// Update extra katanas with offset positions
		if (powerUpActive) {
			for (var k = 0; k < extraKatanas.length; k++) {
				var offsetX = (k + 1) * 80 * Math.sin(LK.ticks * 0.1 + k);
				var offsetY = (k + 1) * 60 * Math.cos(LK.ticks * 0.1 + k);
				extraKatanas[k].updatePosition(x + offsetX, y + offsetY);
			}
		}
		if (isSlicing) {
			katana.checkFruitCollisions();
			// Check collisions for extra katanas too
			if (powerUpActive) {
				for (var k = 0; k < extraKatanas.length; k++) {
					extraKatanas[k].checkFruitCollisions();
				}
			}
		}
	}
	// Track movement for katana health system
	var distance = Math.sqrt(Math.pow(x - lastKatanaX, 2) + Math.pow(y - lastKatanaY, 2));
	movementSamples.push(distance);
	if (movementSamples.length > maxMovementSamples) {
		movementSamples.shift();
	}
	// Calculate average movement in recent samples
	var totalMovement = 0;
	for (var i = 0; i < movementSamples.length; i++) {
		totalMovement += movementSamples[i];
	}
	var avgMovement = totalMovement / movementSamples.length;
	// Only activate health system if katana is in upper 1.5cm (approximately 109 pixels) from top
	var isInUpperScreen = y < 109; // 1.5cm from top of screen (at 72 DPI: 1.5cm ≈ 109 pixels)
	// If movement is very rapid (increased threshold: 50+ pixels per frame on average) AND in upper screen
	if (avgMovement > 50 && movementSamples.length >= maxMovementSamples && isInUpperScreen) {
		katanaHealth -= 3; // Drain health faster for rapid movements
		// Show health bar when taking damage
		if (healthBarContainer.alpha < 1) {
			tween(healthBarContainer, {
				alpha: 1
			}, {
				duration: 200
			});
		}
		// Update health bar fill
		var healthPercent = Math.max(0, katanaHealth / maxKatanaHealth);
		tween(healthBarFill, {
			scaleX: 3 * healthPercent
		}, {
			duration: 100
		});
		// Change color based on health level
		if (healthPercent < 0.3) {
			healthBarFill.tint = 0xE74C3C; // Red
		} else if (healthPercent < 0.6) {
			healthBarFill.tint = 0xF39C12; // Orange
		} else {
			healthBarFill.tint = 0x27AE60; // Green
		}
		// Check if health is depleted
		if (katanaHealth <= 0) {
			katanaHealth = 0;
			katanaParalyzed = true;
			paralyzeTimer = 66; // 1.1 seconds at 60fps
			// Flash katana red to indicate paralysis
			LK.effects.flashObject(katana, 0xFF0000, 1100);
		}
	}
	lastKatanaX = x;
	lastKatanaY = y;
	lastMouseX = x;
	lastMouseY = y;
};
game.down = function (x, y, obj) {
	isSlicing = true;
	katana.updatePosition(x, y);
	// Update extra katanas position on touch down
	if (powerUpActive) {
		for (var k = 0; k < extraKatanas.length; k++) {
			var offsetX = (k + 1) * 80 * Math.sin(LK.ticks * 0.1 + k);
			var offsetY = (k + 1) * 60 * Math.cos(LK.ticks * 0.1 + k);
			extraKatanas[k].updatePosition(x + offsetX, y + offsetY);
		}
	}
};
game.up = function (x, y, obj) {
	isSlicing = false;
};
game.update = function () {
	// Handle start screen state - only show background animation
	if (gameState === 'start') {
		// Only animate background elements on start screen
		// Animate cherry blossom petals falling and swirling
		for (var bp = 0; bp < blossomPetals.length; bp++) {
			var petal = blossomPetals[bp];
			petal.y += Math.sin(LK.ticks * 0.01 + bp) * 0.5 + 0.3;
			petal.x += Math.sin(LK.ticks * 0.008 + bp) * 0.8;
			petal.rotation += 0.02;
			// Reset petal position when it goes off screen
			if (petal.y > 2800) {
				petal.y = -50;
				petal.x = Math.random() * 2048;
			}
			if (petal.x > 2100) {
				petal.x = -50;
			}
		}
		return; // Don't update game logic on start screen
	}
	// Handle game pause state - stop all game activity when paused
	if (gamePaused) {
		return; // Don't update anything when game is paused
	}
	// Animate background elements
	// Animate cherry blossom petals falling and swirling
	for (var bp = 0; bp < blossomPetals.length; bp++) {
		var petal = blossomPetals[bp];
		petal.y += Math.sin(LK.ticks * 0.01 + bp) * 0.5 + 0.3;
		petal.x += Math.sin(LK.ticks * 0.008 + bp) * 0.8;
		petal.rotation += 0.02;
		// Reset petal position when it goes off screen
		if (petal.y > 2800) {
			petal.y = -50;
			petal.x = Math.random() * 2048;
		}
		if (petal.x > 2100) {
			petal.x = -50;
		}
	}
	// Animate mist layers with slow drift
	for (var mist = 0; mist < mistLayers.length; mist++) {
		var mistLayer = mistLayers[mist];
		mistLayer.x += Math.sin(LK.ticks * 0.002 + mist) * 0.2 + 0.1;
		mistLayer.alpha = 0.3 + Math.sin(LK.ticks * 0.005 + mist) * 0.1;
		// Reset position when off screen
		if (mistLayer.x > 2400) {
			mistLayer.x = -400;
		}
	}
	// Animate flowers with gentle bobbing
	for (var f = 0; f < flowers.length; f++) {
		var flower = flowers[f];
		flower.rotation = Math.sin(LK.ticks * 0.02 + f) * 0.2;
		flower.scaleX = 1 + Math.sin(LK.ticks * 0.015 + f) * 0.1;
		flower.scaleY = 1 + Math.sin(LK.ticks * 0.015 + f) * 0.1;
	}
	// Add subtle parallax effect to background layers
	for (var bt = 0; bt < backgroundTrees.length; bt++) {
		var bgTree = backgroundTrees[bt];
		bgTree.x += Math.sin(LK.ticks * 0.001 + bt) * 0.1;
	}
	// Animate hills with very subtle movement
	for (var h = 0; h < hills.length; h++) {
		var hill = hills[h];
		hill.alpha = 0.6 + Math.sin(LK.ticks * 0.003 + h) * 0.1;
	}
	// Gentle sky color animation transitioning between sunset and night
	if (LK.ticks % 120 === 0) {
		var timePhase = Math.sin(LK.ticks * 0.0005) * 0.5 + 0.5; // Oscillates between 0 and 1
		var sunsetNightColors = [[0xFF6B35, 0x2C3E50],
		// Horizon: orange to dark blue
		[0xFF8C42, 0x1B2631],
		// Orange-red to darker blue
		[0xE74C3C, 0x17202A],
		// Deep red to near black
		[0x8E44AD, 0x0B1426],
		// Purple to deep night
		[0x2C3E50, 0x0B1426],
		// Dark blue-purple to deep night
		[0x1B2631, 0x0B1426],
		// Very dark blue to deep night
		[0x17202A, 0x0B1426],
		// Near black to deep night
		[0x0B1426, 0x0B1426] // Deep night to deep night
		];
		for (var s = 0; s < skyLayers.length; s++) {
			var skyLayer = skyLayers[s];
			var sunsetColor = sunsetNightColors[s][0];
			var nightColor = sunsetNightColors[s][1];
			// Interpolate between sunset and night colors
			var r1 = sunsetColor >> 16 & 0xFF;
			var g1 = sunsetColor >> 8 & 0xFF;
			var b1 = sunsetColor & 0xFF;
			var r2 = nightColor >> 16 & 0xFF;
			var g2 = nightColor >> 8 & 0xFF;
			var b2 = nightColor & 0xFF;
			var r = Math.floor(r1 + (r2 - r1) * timePhase);
			var g = Math.floor(g1 + (g2 - g1) * timePhase);
			var b = Math.floor(b1 + (b2 - b1) * timePhase);
			skyLayer.tint = r << 16 | g << 8 | b;
		}
	}
	// Animate snow caps with subtle shimmer
	for (var sc = 0; sc < snowCaps.length; sc++) {
		var snowCap = snowCaps[sc];
		snowCap.alpha = snowCap.alpha + Math.sin(LK.ticks * 0.01 + sc) * 0.05;
	}
	// Spawn shooting stars periodically
	shootingStarSpawnTimer++;
	if (shootingStarSpawnTimer >= shootingStarSpawnRate) {
		shootingStarSpawnTimer = 0;
		// Random chance to spawn (not every time)
		if (Math.random() < 0.7) {
			var shootingStar = new ShootingStar(Math.random() * 500 - 200,
			// Start from left side of screen
			Math.random() * 800 + 100 // Random height in upper portion
			);
			shootingStars.push(shootingStar);
			backgroundContainer.addChild(shootingStar);
		}
	}
	// Update shooting stars and remove expired ones
	for (var ss = shootingStars.length - 1; ss >= 0; ss--) {
		var star = shootingStars[ss];
		star.update();
		// Remove stars that are off screen or expired
		if (star.life <= 0 || star.x > 2400 || star.y > 2800) {
			star.destroy();
			shootingStars.splice(ss, 1);
		}
	}
	// Update distant and mid buildings
	for (var db = 0; db < distantBuildings.length; db++) {
		distantBuildings[db].update();
	}
	for (var mb = 0; mb < midBuildings.length; mb++) {
		midBuildings[mb].update();
	}
	// Spawn fruits
	spawnTimer++;
	if (spawnTimer >= spawnRate) {
		spawnTimer = 0;
		var fruitType = fruitTypes[Math.floor(Math.random() * fruitTypes.length)];
		var fruit = new Fruit(fruitType);
		fruit.x = Math.random() * 1800 + 124; // Random x position within screen bounds
		fruit.y = -100; // Start above screen
		fruits.push(fruit);
		game.addChild(fruit);
		// Spawn rate is now controlled by difficulty level in slice function
	}
	// Update fruits and remove off-screen ones
	for (var i = fruits.length - 1; i >= 0; i--) {
		var fruit = fruits[i];
		// Check if fruit touched the ground (game over condition)
		if (fruit.y > 2732 && !fruit.sliced) {
			// Game over - fruit touched the ground
			LK.showGameOver();
			return; // Stop game execution
		}
		// Remove fruits that fall off screen
		if (fruit.y > 2800) {
			fruit.destroy();
			fruits.splice(i, 1);
		}
	}
	// Update particles
	for (var j = particles.length - 1; j >= 0; j--) {
		var particle = particles[j];
		if (particle.life <= 0) {
			particles.splice(j, 1);
		}
	}
	// Update katana health system
	if (katanaParalyzed) {
		paralyzeTimer--;
		if (paralyzeTimer <= 0) {
			katanaParalyzed = false;
			katanaHealth = maxKatanaHealth; // Restore full health
			// Update health bar to full
			tween(healthBarFill, {
				scaleX: 3
			}, {
				duration: 300
			});
			healthBarFill.tint = 0x27AE60; // Green
			// Hide health bar after recovery
			tween(healthBarContainer, {
				alpha: 0
			}, {
				duration: 1000
			});
		}
	} else {
		// Gradually regenerate health when not making rapid movements
		if (katanaHealth < maxKatanaHealth) {
			katanaHealth += 0.5; // Slow regeneration
			if (katanaHealth > maxKatanaHealth) {
				katanaHealth = maxKatanaHealth;
			}
			// Update health bar fill
			var healthPercent = katanaHealth / maxKatanaHealth;
			healthBarFill.scaleX = 3 * healthPercent;
			// Update color
			if (healthPercent < 0.3) {
				healthBarFill.tint = 0xE74C3C; // Red
			} else if (healthPercent < 0.6) {
				healthBarFill.tint = 0xF39C12; // Orange
			} else {
				healthBarFill.tint = 0x27AE60; // Green
			}
			// Hide health bar when fully recovered and not being used
			if (katanaHealth >= maxKatanaHealth && healthBarContainer.alpha > 0) {
				tween(healthBarContainer, {
					alpha: 0
				}, {
					duration: 2000
				});
			}
		}
	}
};