/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	totalScore: 0,
	gamesPlayed: 0,
	fruitsSliced: 0,
	playerId: "",
	playerName: "",
	allScores: []
});

/**** 
* 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
	});
	// Simple straight fall
	self.velocityY = self.fallSpeed;
	self.gravity = 0.1;
	self.update = function () {
		if (!self.sliced) {
			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 basePoints = 0;
		switch (self.fruitType) {
			case 'apple':
				basePoints = 10;
				break;
			case 'orange':
				basePoints = 15;
				break;
			case 'watermelon':
				basePoints = 30;
				break;
			case 'pineapple':
				basePoints = 25;
				break;
			case 'banana':
				basePoints = 20;
				break;
		}
		var points = basePoints;
		LK.setScore(LK.getScore() + points);
		storage.fruitsSliced++;
		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
// Generate unique player ID if not exists
// Initialize weapons object properly
function _typeof2(o) {
	"@babel/helpers - typeof";
	return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof2(o);
}
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
if (!storage.playerId) {
	storage.playerId = 'player_' + Date.now() + '_' + Math.floor(Math.random() * 10000);
	storage.playerName = 'Jugador_' + Math.floor(Math.random() * 9999);
}
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 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)
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;
var powerUpTimer = 0;
var powerUpMaxTimer = 1050; // 17.5 seconds at 60fps
// Create katana
var katana = game.addChild(new Katana());
katana.x = 1024;
katana.y = 1366;
katana.visible = false; // Hide katana on start screen
// 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 with 3D effect
var powerBarLabelShadow = new Text2('KATANA-NINJA', {
	size: 30,
	fill: 0x000000
});
powerBarLabelShadow.anchor.set(1, 0);
powerBarLabelShadow.x = 2;
powerBarLabelShadow.y = -33;
powerBarLabelShadow.alpha = 0.6;
powerBarContainer.addChild(powerBarLabelShadow);
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 exit button positioned at bottom center
var exitButtonContainer = new Container();
LK.gui.bottom.addChild(exitButtonContainer);
// Create exit button background
var exitBtnBg = LK.getAsset('shape', {
	anchorX: 0.5,
	anchorY: 1,
	scaleX: 2,
	scaleY: 1.2
});
exitBtnBg.tint = 0xE74C3C;
exitBtnBg.alpha = 0.9;
exitButtonContainer.addChild(exitBtnBg);
// Create exit button text
var exitBtnText = new Text2('SALIR', {
	size: 40,
	fill: 0xFFFFFF
});
exitBtnText.anchor.set(0.5, 0.5);
exitBtnText.x = 0;
exitBtnText.y = -30;
exitButtonContainer.addChild(exitBtnText);
// Position exit button at bottom center with padding
exitButtonContainer.x = 0;
exitButtonContainer.y = -120; // 120px from bottom edge
exitButtonContainer.visible = false; // Hide on start screen
// Exit button interaction
exitButtonContainer.down = function (x, y, obj) {
	// Make all fruits disintegrate with animation
	for (var i = fruits.length - 1; i >= 0; i--) {
		var fruit = fruits[i];
		// Animate fruit disintegration
		tween(fruit, {
			alpha: 0,
			scaleX: 0.1,
			scaleY: 0.1,
			rotation: Math.PI * 2
		}, {
			duration: 500,
			onFinish: function onFinish() {
				// Destroy fruit after animation
				if (fruit && fruit.destroy) {
					fruit.destroy();
				}
			}
		});
	}
	// Clear fruits array
	fruits = [];
	// Return to start screen
	gameState = 'start';
	startScreenVisible = true;
	// Hide game UI elements
	scoreContainer.visible = false;
	healthBarContainer.visible = false;
	powerBarContainer.visible = false;
	exitButtonContainer.visible = false;
	// Show start screen
	startScreenContainer.visible = true;
	startScreenContainer.alpha = 1;
	startScreenContainer.scaleX = 1;
	startScreenContainer.scaleY = 1;
	// Hide katana on start screen
	katana.visible = false;
};
// 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 with 3D effect
// Create multiple shadow layers for depth
var titleShadow3 = new Text2('FRUIT NINJA', {
	size: 120,
	fill: 0x000000
});
titleShadow3.anchor.set(0.5, 0.5);
titleShadow3.x = 1024 + 8;
titleShadow3.y = 800 + 8;
titleShadow3.alpha = 0.3;
startScreenContainer.addChild(titleShadow3);
var titleShadow2 = new Text2('FRUIT NINJA', {
	size: 120,
	fill: 0x8B0000
});
titleShadow2.anchor.set(0.5, 0.5);
titleShadow2.x = 1024 + 4;
titleShadow2.y = 800 + 4;
titleShadow2.alpha = 0.5;
startScreenContainer.addChild(titleShadow2);
var titleShadow1 = new Text2('FRUIT NINJA', {
	size: 120,
	fill: 0xCD5C5C
});
titleShadow1.anchor.set(0.5, 0.5);
titleShadow1.x = 1024 + 2;
titleShadow1.y = 800 + 2;
titleShadow1.alpha = 0.7;
startScreenContainer.addChild(titleShadow1);
var gameTitle = new Text2('FRUIT NINJA', {
	size: 120,
	fill: 0xFF6B6B
});
gameTitle.anchor.set(0.5, 0.5);
gameTitle.x = 1024;
gameTitle.y = 800;
startScreenContainer.addChild(gameTitle);
// Add pulsing glow effect
tween(gameTitle, {
	scaleX: 1.05,
	scaleY: 1.05
}, {
	duration: 2000,
	onComplete: function onComplete() {
		tween(gameTitle, {
			scaleX: 1.0,
			scaleY: 1.0
		}, {
			duration: 2000
		});
	}
});
// Create subtitle with 3D effect
var subtitleShadow2 = new Text2('KATANA MASTER', {
	size: 60,
	fill: 0x000000
});
subtitleShadow2.anchor.set(0.5, 0.5);
subtitleShadow2.x = 1024 + 6;
subtitleShadow2.y = 950 + 6;
subtitleShadow2.alpha = 0.4;
startScreenContainer.addChild(subtitleShadow2);
var subtitleShadow1 = new Text2('KATANA MASTER', {
	size: 60,
	fill: 0xB8860B
});
subtitleShadow1.anchor.set(0.5, 0.5);
subtitleShadow1.x = 1024 + 3;
subtitleShadow1.y = 950 + 3;
subtitleShadow1.alpha = 0.6;
startScreenContainer.addChild(subtitleShadow1);
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);
// Add subtle rotation animation
tween(gameSubtitle, {
	rotation: 0.05
}, {
	duration: 3000,
	onComplete: function onComplete() {
		tween(gameSubtitle, {
			rotation: -0.05
		}, {
			duration: 3000,
			onComplete: function onComplete() {
				tween(gameSubtitle, {
					rotation: 0
				}, {
					duration: 3000
				});
			}
		});
	}
});
// 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 shop button
var shopBtn = LK.getAsset('shape', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 4,
	scaleY: 1.5
});
shopBtn.tint = 0x8E44AD;
shopBtn.x = 1024;
shopBtn.y = 1450;
startScreenContainer.addChild(shopBtn);
var shopText = new Text2('Tienda\nPROXIMAMENTE', {
	size: 40,
	fill: 0xFFFFFF
});
shopText.anchor.set(0.5, 0.5);
shopText.x = 1024;
shopText.y = 1450;
startScreenContainer.addChild(shopText);
// Create leaderboard table with 3D title
var leaderboardTitleShadow = new Text2('TOP JUGADORES', {
	size: 60,
	fill: 0x000000
});
leaderboardTitleShadow.anchor.set(0.5, 0.5);
leaderboardTitleShadow.x = 1024 + 3;
leaderboardTitleShadow.y = 1650 + 3;
leaderboardTitleShadow.alpha = 0.5;
startScreenContainer.addChild(leaderboardTitleShadow);
var leaderboardTitle = new Text2('TOP JUGADORES', {
	size: 60,
	fill: 0xFF6B6B
});
leaderboardTitle.anchor.set(0.5, 0.5);
leaderboardTitle.x = 1024;
leaderboardTitle.y = 1650;
startScreenContainer.addChild(leaderboardTitle);
// Create leaderboard entries
var leaderboardEntries = [];
for (var l = 0; l < 3; l++) {
	var entryText = new Text2('', {
		size: 48,
		fill: 0xFFFFFF
	});
	entryText.anchor.set(0.5, 0.5);
	entryText.x = 1024;
	entryText.y = 1740 + l * 60;
	startScreenContainer.addChild(entryText);
	leaderboardEntries.push(entryText);
}
// Create instructions
var instructionText = new Text2('Desliza para cortar frutas\nEvita que toquen el suelo', {
	size: 35,
	fill: 0xFFFFFF
});
instructionText.anchor.set(0.5, 0.5);
instructionText.x = 1024;
instructionText.y = 1950;
startScreenContainer.addChild(instructionText);
// Initialize leaderboard on startup
updateGlobalLeaderboard();
// Play button interaction
playBtn.down = function (x, y, obj) {
	// Reset all game variables to start fresh
	LK.setScore(0);
	fruits = [];
	particles = [];
	spawnTimer = 0;
	spawnRate = 90;
	baseSpawnRate = 90;
	baseFallSpeed = 2;
	currentDifficultyLevel = 0;
	katanaHealth = 100;
	maxKatanaHealth = 100;
	katanaParalyzed = false;
	paralyzeTimer = 0;
	lastKatanaX = 0;
	lastKatanaY = 0;
	movementSamples = [];
	powerUpActive = false;
	powerUpActivated = false;
	powerUpTimer = 0;
	powerUpMaxTimer = 1050;
	// Clear any existing extra katanas
	for (var k = 0; k < extraKatanas.length; k++) {
		extraKatanas[k].destroy();
	}
	extraKatanas = [];
	// Reset katana appearance and position
	katana.destroy();
	katana = game.addChild(new Katana());
	katana.tint = 0xFFFFFF;
	katana.x = 1024;
	katana.y = 1366;
	katana.visible = true; // Show katana when game starts
	// Reset power bar
	powerBarFill.scaleX = 0;
	powerBarFill.tint = 0xFFD700;
	powerBarLabel.setText('KATANA-NINJA');
	// Reset health bar
	healthBarFill.scaleX = 3;
	healthBarFill.tint = 0x27AE60;
	healthBarContainer.alpha = 0;
	// Update score display
	updateScoreDisplay(0);
	// Start the game
	gameState = 'playing';
	startScreenVisible = false;
	// Track game start
	storage.gamesPlayed++;
	// Update leaderboard when starting game
	updateGlobalLeaderboard();
	// Show game UI elements
	scoreContainer.visible = true;
	healthBarContainer.visible = true;
	powerBarContainer.visible = true;
	exitButtonContainer.visible = true;
	// Animate start screen out
	tween(startScreenContainer, {
		alpha: 0,
		scaleX: 0.8,
		scaleY: 0.8
	}, {
		duration: 500,
		onComplete: function onComplete() {
			startScreenContainer.visible = false;
		}
	});
};
// Database functions for player data management
function savePlayerScore(score) {
	// Save the current game score
	storage.currentScore = score;
	// Update total/best score if this is better
	if (score > (storage.totalScore || 0)) {
		storage.totalScore = score;
	}
	// Update statistics
	storage.gamesPlayed = storage.gamesPlayed || 0;
	storage.lastPlayDate = Date.now();
	// Save all scores in a persistent array for leaderboard
	// Ensure allScores is properly initialized as an array
	if (!storage.allScores || !Array.isArray(storage.allScores)) {
		storage.allScores = [];
	}
	var currentScores = storage.allScores.slice(); // Create a copy of the array
	// Add current score to the array
	var newScoreEntry = {
		score: score,
		playerName: storage.playerName,
		playerId: storage.playerId,
		date: Date.now()
	};
	currentScores.push(newScoreEntry);
	// Sort scores in descending order and keep only top 10
	currentScores.sort(function (a, b) {
		return b.score - a.score;
	});
	if (currentScores.length > 10) {
		currentScores = currentScores.slice(0, 10);
	}
	// Save back to storage
	storage.allScores = currentScores;
	return {
		saved: true,
		currentScore: storage.currentScore,
		bestScore: storage.totalScore,
		topScores: storage.allScores
	};
}
function getPlayerData() {
	// Return all player data
	return {
		score: {
			current: storage.currentScore || 0,
			best: storage.totalScore || 0
		},
		stats: {
			gamesPlayed: storage.gamesPlayed || 0,
			fruitsSliced: storage.fruitsSliced || 0,
			lastPlayed: storage.lastPlayDate || null
		},
		player: {
			id: storage.playerId || '',
			name: storage.playerName || ''
		},
		leaderboard: storage.allScores || []
	};
}
function getTopScores() {
	// Return top scores for leaderboard
	return storage.allScores || [];
}
function resetPlayerData() {
	// Reset all player data (useful for new game or reset)
	storage.currentScore = 0;
	storage.totalScore = 0;
	storage.gamesPlayed = 0;
	storage.fruitsSliced = 0;
	storage.lastPlayDate = null;
	// Keep the scores array but can optionally clear it
	// storage.allScores = [];
	return {
		reset: true,
		message: 'Player data has been reset but scores preserved'
	};
}
// Function to update leaderboard display with real saved scores
function updateGlobalLeaderboard() {
	var topScores = getTopScores();
	for (var l = 0; l < leaderboardEntries.length; l++) {
		if (l < topScores.length) {
			var scoreEntry = topScores[l];
			var displayName = scoreEntry.playerName || 'Jugador';
			leaderboardEntries[l].setText(l + 1 + '. ' + displayName + ' - ' + scoreEntry.score);
			// Highlight current player's scores
			if (scoreEntry.playerId === storage.playerId) {
				leaderboardEntries[l].fill = 0xFFD700; // Gold for current player
			} else {
				leaderboardEntries[l].fill = 0xFFFFFF; // White for other players
			}
		} else {
			leaderboardEntries[l].setText(l + 1 + '. ---');
			leaderboardEntries[l].fill = 0x888888;
		}
	}
}
// Play button hover effect
playBtn.move = function (x, y, obj) {
	playBtn.alpha = 0.8;
};
// Exit button hover effect
exitButtonContainer.move = function (x, y, obj) {
	exitBtnBg.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);
	// Save the score using database function
	var scoreResult = savePlayerScore(newScore);
	// Update leaderboard whenever score changes
	updateGlobalLeaderboard();
	// 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;
	// Set power duration (17.5 seconds = 1050 frames at 60fps)
	powerUpTimer = 1050;
	powerUpMaxTimer = 1050;
	// Create visual explosion effect
	LK.effects.flashScreen(0xFFD700, 2000); // Golden flash
	// Create additional katanas with proper left/right positioning
	for (var k = 0; k < 2; k++) {
		var extraKatana = game.addChild(new Katana());
		extraKatana.x = katana.x;
		extraKatana.y = katana.y;
		extraKatana.katanaIndex = k; // Assign index for positioning
		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 proper left/center/right positioning
		if (powerUpActive) {
			for (var k = 0; k < extraKatanas.length; k++) {
				var spacing = 200; // Increased spacing for better separation
				var offsetX = 0;
				var offsetY = 0;
				// Position katanas: left (-200px), center (0px), right (+200px)
				if (k === 0) {
					// Left katana
					offsetX = -spacing;
				} else if (k === 1) {
					// Right katana  
					offsetX = spacing;
				}
				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 spacing = 200; // Consistent spacing with move handler
			var offsetX = 0;
			var offsetY = 0;
			// Position katanas: left (-200px), center (0px), right (+200px)
			if (k === 0) {
				// Left katana
				offsetX = -spacing;
			} else if (k === 1) {
				// Right katana  
				offsetX = spacing;
			}
			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
	}
	// 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)];
		// Create fruit with simple falling behavior
		var fruit = new Fruit(fruitType);
		// Spawn fruit at random horizontal position across entire screen width
		fruit.x = Math.random() * 2048;
		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];
		// Explicitly call fruit update to ensure falling continues after pause
		fruit.update();
		// Check if fruit touched the ground (game over condition) - only if still playing
		if (fruit.y > 2732 && !fruit.sliced && gameState === 'playing') {
			// Save final score before game over
			var finalScore = LK.getScore();
			savePlayerScore(finalScore);
			updateGlobalLeaderboard();
			// 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 power-up timer and bar
	if (powerUpActive) {
		powerUpTimer--;
		// Update power bar to show countdown
		var powerProgress = powerUpTimer / powerUpMaxTimer;
		var powerBarWidth = 2.5 * powerProgress;
		tween(powerBarFill, {
			scaleX: powerBarWidth
		}, {
			duration: 100
		});
		// Change power bar color during countdown
		if (powerProgress <= 0.3) {
			powerBarFill.tint = 0xFF0000; // Red when almost finished
			powerBarLabel.setText('ENDING!');
		} else if (powerProgress <= 0.6) {
			powerBarFill.tint = 0xFF6B35; // Orange when halfway
			powerBarLabel.setText('ACTIVE');
		} else {
			powerBarFill.tint = 0x00FF00; // Green when active
			powerBarLabel.setText('ACTIVE');
		}
		// Deactivate power when timer reaches 0
		if (powerUpTimer <= 0) {
			deactivatePowerUp();
		}
	}
	// Power-up deactivation function
	function deactivatePowerUp() {
		powerUpActive = false;
		powerUpTimer = 0;
		// Remove extra katanas
		for (var k = 0; k < extraKatanas.length; k++) {
			extraKatanas[k].destroy();
		}
		extraKatanas = [];
		// Reset main katana appearance
		katana.tint = 0xFFFFFF;
		// Reset power bar
		powerBarFill.scaleX = 0;
		powerBarFill.tint = 0xFFD700;
		powerBarLabel.setText('KATANA-NINJA');
		// Reset power activation flag so it can be triggered again
		powerUpActivated = false;
	}
	// Track mouse movement
	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
				});
			}
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -1181,9 +1181,13 @@
 	// Update statistics
 	storage.gamesPlayed = storage.gamesPlayed || 0;
 	storage.lastPlayDate = Date.now();
 	// Save all scores in a persistent array for leaderboard
-	var currentScores = storage.allScores || [];
+	// Ensure allScores is properly initialized as an array
+	if (!storage.allScores || !Array.isArray(storage.allScores)) {
+		storage.allScores = [];
+	}
+	var currentScores = storage.allScores.slice(); // Create a copy of the array
 	// Add current score to the array
 	var newScoreEntry = {
 		score: score,
 		playerName: storage.playerName,