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

/**** 
* Classes
****/ 
// Clase Cannon para mostrar el cañón y animar disparo
var Cannon = Container.expand(function () {
	var self = Container.call(this);
	// Asset del cañón (ahora usa la imagen personalizada)
	self.cannonAsset = self.attachAsset('cannon', {
		anchorX: 0.5,
		anchorY: 1
	});
	// Efecto de fogonazo al disparar
	self.flash = null;
	// Estado
	self.isVisible = true;
	self.isShooting = false;
	// Posición base (centrado horizontal, abajo)
	self.baseX = 2048 / 2;
	// Coloca el cañón pegado a la parte baja del juego (anchorY:1, así que baseY es exactamente el borde inferior)
	self.baseY = 2732;
	self.x = self.baseX;
	self.y = self.baseY;
	// Mostrar cañón
	self.show = function () {
		self.visible = true;
		self.isVisible = true;
		// Animar subida si estaba oculto
		tween(self, {
			y: self.baseY
		}, {
			duration: 350,
			easing: tween.cubicOut
		});
	};
	// Animar disparo (pequeño retroceso y fogonazo)
	self.shoot = function () {
		if (self.isShooting) {
			return;
		}
		self.isShooting = true;
		// Retroceso rápido
		tween(self, {
			y: self.baseY - 60
		}, {
			duration: 80,
			easing: tween.cubicOut,
			onFinish: function onFinish() {
				// Regresa a posición base
				tween(self, {
					y: self.baseY
				}, {
					duration: 120,
					easing: tween.cubicIn,
					onFinish: function onFinish() {
						self.isShooting = false;
					}
				});
			}
		});
		// Fogonazo visual
		if (!self.flash) {
			self.flash = self.attachAsset('cut_zone', {
				anchorX: 0.5,
				anchorY: 1,
				x: 0,
				y: -self.cannonAsset.height + 30,
				scaleX: 0.5,
				scaleY: 0.3,
				alpha: 0.0,
				color: 0xffffcc
			});
		}
		self.flash.alpha = 0.7;
		self.flash.scaleX = 0.5;
		self.flash.scaleY = 0.3;
		tween(self.flash, {
			alpha: 0,
			scaleX: 1.2,
			scaleY: 0.7
		}, {
			duration: 120,
			easing: tween.linear
		});
	};
	return self;
});
// Clase para el objeto de cuenta regresiva "Go"
var CountdownGo = Container.expand(function () {
	var self = Container.call(this);
	self.asset = self.attachAsset('Go', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = self.asset.width / 2;
	self.isActive = true;
	self.state = 'countdown';
	self.destroyCountdown = function () {
		self.isActive = false;
		self.visible = false;
		self.destroy();
	};
	return self;
});
// Clase para el objeto de cuenta regresiva "1"
var CountdownOne = Container.expand(function () {
	var self = Container.call(this);
	self.asset = self.attachAsset('1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = self.asset.width / 2;
	self.isActive = true;
	self.state = 'countdown';
	self.destroyCountdown = function () {
		self.isActive = false;
		self.visible = false;
		self.destroy();
	};
	return self;
});
// Clase para el objeto de cuenta regresiva "2"
var CountdownTwo = Container.expand(function () {
	var self = Container.call(this);
	self.asset = self.attachAsset('2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = self.asset.width / 2;
	self.isActive = true;
	self.state = 'countdown';
	self.destroyCountdown = function () {
		self.isActive = false;
		self.visible = false;
		self.destroy();
	};
	return self;
});
// Clase para la fruta entera
var Fruit = Container.expand(function () {
	var self = Container.call(this);
	// Selección aleatoria de tipo de fruta
	var fruitTypes = ['fruit_apple', 'fruit_lemon', 'fruit_orange', 'fruit_kiwi', 'fruit_plum'];
	self.fruitType = fruitTypes[Math.floor(Math.random() * fruitTypes.length)];
	// Asset de la fruta
	self.fruitAsset = self.attachAsset(self.fruitType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = self.fruitAsset.width / 2;
	// Estado
	self.isCut = false;
	self.isActive = true; // Si está en juego
	// Para saber si ya fue cortada
	self.cut = function () {
		if (self.isCut) {
			return;
		}
		self.isCut = true;
		self.isActive = false;
		self.visible = false;
	};
	return self;
});
// Clase para la fruta cortada (dos mitades)
var FruitCut = Container.expand(function () {
	var self = Container.call(this);
	// Recibe tipo de fruta, posición base, rotación y escala
	self.init = function (fruitType, x, y, rotation, scale) {
		if (typeof rotation === "undefined") {
			rotation = 0;
		}
		if (typeof scale === "undefined") {
			scale = 1;
		}
		// Para las frutas, usar assets de mitades cortadas específicos por tipo de fruta
		var leftAssetId = 'fruit_apple_cut_left';
		var rightAssetId = 'fruit_apple_cut_right';
		if (fruitType === 'fruit_apple') {
			leftAssetId = 'fruit_apple_cut_left';
			rightAssetId = 'fruit_apple_cut_right';
		} else if (fruitType === 'fruit_lemon') {
			leftAssetId = 'fruit_lemon_cut_left';
			rightAssetId = 'fruit_lemon_cut_right';
		} else if (fruitType === 'fruit_orange') {
			leftAssetId = 'fruit_orange_cut_left';
			rightAssetId = 'fruit_orange_cut_right';
		} else if (fruitType === 'fruit_plum') {
			leftAssetId = 'fruit_plum_cut_left';
			rightAssetId = 'fruit_plum_cut_right';
		} else if (fruitType === 'fruit_kiwi') {
			leftAssetId = 'fruit_kiwi_cut_left';
			rightAssetId = 'fruit_kiwi_cut_right';
		}
		// Mitad izquierda reflejada horizontalmente (flipX: 1)
		self.left = self.attachAsset(leftAssetId, {
			anchorX: 1,
			anchorY: 0.5,
			scaleX: scale,
			scaleY: scale,
			x: 0,
			y: 0,
			flipX: 1
		});
		// Mitad derecha normal
		self.right = self.attachAsset(rightAssetId, {
			anchorX: 0,
			anchorY: 0.5,
			scaleX: scale,
			scaleY: scale,
			x: 0,
			y: 0
		});
		self.x = x;
		self.y = y;
		self.left.rotation = rotation;
		self.right.rotation = rotation;
		self.rotation = rotation;
	};
	// Animación de separación
	self.animate = function (_onFinish) {
		// Reduce size to 80% immediately
		tween(self.left, {
			x: -80,
			rotation: self.left.rotation + 0.7,
			scaleX: self.left.scaleX * 0.8,
			scaleY: self.left.scaleY * 0.8
		}, {
			duration: 500,
			easing: tween.cubicOut
		});
		tween(self.right, {
			x: 80,
			rotation: self.right.rotation - 0.7,
			scaleX: self.right.scaleX * 0.8,
			scaleY: self.right.scaleY * 0.8
		}, {
			duration: 500,
			easing: tween.cubicOut,
			onFinish: function onFinish() {
				// Fade out both halves after movement/scaling
				tween(self.left, {
					alpha: 0
				}, {
					duration: 350,
					easing: tween.linear
				});
				tween(self.right, {
					alpha: 0
				}, {
					duration: 350,
					easing: tween.linear,
					onFinish: function onFinish() {
						if (_onFinish) {
							_onFinish();
						}
					}
				});
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Inicia la música de fondo en loop al iniciar el juego
LK.playMusic('bgmusic', {
	loop: false
});
// Fondo superior azul
// Fondo inferior café
// Fondo inferior (parte baja de la pantalla) - café
var bottomBg = LK.getAsset('bottom_bg', {
	anchorX: 0,
	anchorY: 1,
	x: 0,
	y: 2732
});
game.addChild(bottomBg);
// Fondo superior (parte alta de la pantalla) - azul
var topBg = LK.getAsset('top_bg', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0
});
game.addChild(topBg);
// Asset personalizado para el cañón (reemplaza el cut_line por una imagen de cañón)
// scoreTxt oculto para evitar error de referencia y mantener compatibilidad con updateScore
var scoreTxt = new Text2('', {
	size: 1,
	fill: "#222",
	alpha: 0 // completamente invisible
});
scoreTxt.visible = false;
// Línea negra horizontal de izquierda a derecha, aún más gruesa y un poco más abajo en el eje Y
var horizontalLine = LK.getAsset('vertical_line', {
	anchorX: 0,
	anchorY: 0.5,
	x: 0,
	// Baja la línea: ahora 540px respecto al centro vertical
	y: 2732 / 2 + 540,
	width: 2048,
	height: 120,
	// mucho más gruesa
	color: 0x000000,
	shape: 'box'
});
// Instancia y agrega el cañón
var cannon = new Cannon();
game.addChild(horizontalLine); // Asegura que la línea esté sobre el fondo pero debajo de frutas y cañón
game.addChild(cannon);
cannon.show();
var frutasGeneradas = 0;
var frutasFalladas = 0;
var fruits = [];
var fallingFruits = [];
var cutFruits = [];
var frutasFalladasTimeout = null;
var fruitSpeed = 25;
var cutZoneAsset = LK.getAsset('cut_zone', {
	anchorX: 0.5,
	anchorY: 0.5
});
var cutZoneRadius = cutZoneAsset.width / 2;
cutZoneAsset.destroy();
var canCut = true;
var lastTouchTick = -100;
function updateScore(val) {
	LK.setScore(val);
	scoreTxt.setText(val);
}
function tryCutFruit(x, y) {
	if (!canCut) {
		return;
	}
	canCut = false;
	lastTouchTick = LK.ticks;
	for (var i = 0; i < fallingFruits.length; i++) {
		var fruit = fallingFruits[i];
		if (!fruit.isActive) {
			continue;
		}
		if (fruit.state === 'cuttable') {
			var dx = x - fruit.x;
			var dy = y - fruit.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist <= fruit.radius * fruit.scaleX) {
				fruit.cut();
				if (fruit.cutZoneCircle) {
					fruit.cutZoneCircle.destroy();
					fruit.cutZoneCircle = null;
				}
				LK.getSound('cut').play();
				// Animación de corte para todas las frutas: mostrar sprite partido, NO el círculo blanco
				var fruitCut = new FruitCut();
				fruitCut.init(fruit.fruitType, fruit.x, fruit.y, fruit.rotation, fruit.scaleX);
				game.addChild(fruitCut);
				// Asegura que la línea negra esté sobre las frutas cortadas pero debajo del cañón
				if (horizontalLine && horizontalLine.parent) {
					horizontalLine.parent.removeChild(horizontalLine);
					game.addChild(horizontalLine);
				}
				// Asegura que el cañón siempre esté al frente
				if (cannon && cannon.parent) {
					cannon.parent.removeChild(cannon);
					game.addChild(cannon);
				}
				fruitCut.animate(function () {
					fruitCut.destroy();
				});
				cutFruits.push(fruitCut);
				frutasGeneradas++;
				updateScore(LK.getScore() + 1);
				return;
			}
		}
	}
}
game.down = function (x, y, obj) {
	tryCutFruit(x, y);
};
// Main update
game.update = function () {
	// Permitir corte nuevamente tras 6 ticks (~100ms)
	if (!canCut && LK.ticks - lastTouchTick > 6) {
		canCut = true;
	}
	// --- SISTEMA DE BALAS POR RONDA (5 balas, 1s entre cada una, 7s delay antes de mostrar en pantalla superior) ---
	if (typeof roundState === "undefined") {
		// Estados posibles: 'waiting', 'spawning', 'waitingFruits'
		roundState = 'waiting';
		roundBullets = 7; // 3 countdown objects + 4 fruits (stage 1)
		roundFruitsQueue = [];
		roundFruitsActive = [];
		roundBulletsFired = 0;
		roundDelayTicks = 0;
		currentStage = 1; // Track current stage (1 or 2)
		roundDelayBetweenRounds = 120; // 2 seconds between rounds
	}
	if (roundState === 'waiting') {
		// Limpiar arrays de frutas y mitades cortadas de la ronda anterior
		for (var i = fruits.length - 1; i >= 0; i--) {
			if (fruits[i]) {
				fruits[i].destroy();
			}
		}
		fruits = [];
		for (var i = fallingFruits.length - 1; i >= 0; i--) {
			if (fallingFruits[i]) {
				fallingFruits[i].destroy();
			}
		}
		fallingFruits = [];
		for (var i = cutFruits.length - 1; i >= 0; i--) {
			if (cutFruits[i]) {
				cutFruits[i].destroy();
			}
		}
		cutFruits = [];
		// Limpiar arrays de control de ronda
		if (typeof roundFruitsQueue !== "undefined") {
			for (var i = roundFruitsQueue.length - 1; i >= 0; i--) {
				if (roundFruitsQueue[i] && roundFruitsQueue[i].destroy) {
					roundFruitsQueue[i].destroy();
				}
			}
		}
		roundFruitsQueue = [];
		if (typeof roundFruitsActive !== "undefined") {
			for (var i = roundFruitsActive.length - 1; i >= 0; i--) {
				if (roundFruitsActive[i] && roundFruitsActive[i].destroy) {
					roundFruitsActive[i].destroy();
				}
			}
		}
		roundFruitsActive = [];
		// Reset meta de ronda
		roundBulletsFired = 0;
		roundNextBulletTick = LK.ticks;
		roundDelayTicks = 0;
		// Set round bullets based on current stage
		if (currentStage === 1) {
			roundBullets = 7; // 3 countdown + 4 fruits
			// Schedule stage 2 to start 8 seconds after stage 1 begins
			if (typeof stage2Scheduled === "undefined" || !stage2Scheduled) {
				stage2Scheduled = true;
				LK.setTimeout(function () {
					// Start stage 2
					currentStage = 2;
					roundState = 'waiting';
					stage2Scheduled = false;
					// Schedule stage 3 to start 5 seconds after stage 2 begins
					if (typeof stage3Scheduled === "undefined" || !stage3Scheduled) {
						stage3Scheduled = true;
						LK.setTimeout(function () {
							currentStage = 3;
							roundState = 'waiting';
							stage3Scheduled = false;
						}, 4000); // 5 seconds after stage 2 starts
					}
				}, 10300); // 8 seconds
			}
		} else if (currentStage === 2) {
			roundBullets = 3; // 3 fruits only, no countdown
			countdownObjectsFired = 3; // Skip countdown in stage 2
			// Schedule stage 3 to start 5 seconds after stage 2 begins (if not already scheduled)
			if (typeof stage3Scheduled === "undefined" || !stage3Scheduled) {
				stage3Scheduled = true;
				LK.setTimeout(function () {
					currentStage = 3;
					roundState = 'waiting';
					stage3Scheduled = false;
				}, 1000); // 5 seconds after stage 2 starts
			}
		} else if (currentStage === 3) {
			roundBullets = 4; // 4 frutas en la tercera etapa
			countdownObjectsFired = 4; // No countdown en la etapa 3
		}
		// Esperar un frame antes de permitir el spawn para evitar generación múltiple
		if (typeof roundJustReset === "undefined" || !roundJustReset) {
			roundJustReset = true;
			return;
		} else {
			roundJustReset = false;
			roundState = 'spawning';
			goShotTick = undefined;
		}
	}
	if (roundState === 'spawning') {
		// Espera inicial antes de cualquier disparo
		if (typeof roundStartTick === "undefined") {
			roundStartTick = LK.ticks;
		}
		var delay = 20; // ⏱️ Espera de 2 segundos (120 ticks)
		if (LK.ticks - roundStartTick < delay) {
			return; // ⏳ Aún esperando el inicio
		}
		// Ensure round variables are properly initialized
		if (typeof roundFruitsQueue === "undefined") {
			roundFruitsQueue = [];
		}
		if (typeof roundFruitsActive === "undefined") {
			roundFruitsActive = [];
		}
		// Disparar los objetos de cuenta regresiva "1", "2", "Go" en los primeros tres disparos
		if (typeof countdownObjectsFired === "undefined") {
			countdownObjectsFired = 0;
		}
		if (roundBulletsFired < roundBullets && LK.ticks >= roundNextBulletTick) {
			var margin = 180;
			var fruitX = margin + Math.random() * (2048 - 2 * margin);
			cannon.x = fruitX;
			cannon.show();
			cannon.shoot();
			// Dispara "1", "2", "Go" en los primeros tres disparos
			if (countdownObjectsFired === 0) {
				var obj1 = new CountdownOne();
				obj1.x = fruitX;
				obj1.y = 2732 + obj1.radius - 120;
				obj1.startY = obj1.y;
				obj1.targetY = 2732 / 2 + 600;
				obj1.state = 'rising';
				obj1.ticks = 0;
				obj1.roundMeta = {
					hasCrossed: false,
					crossedTick: null,
					showScheduled: false,
					showTimeout: null,
					destroyed: false
				};
				fruits.push(obj1);
				roundFruitsQueue.push(obj1);
				game.addChild(obj1);
				// Mostrar "1" centrado y gigante con fade out
				var centerObj1 = new CountdownOne();
				centerObj1.x = 2048 / 2;
				centerObj1.y = 2732 / 2;
				centerObj1.scaleX = centerObj1.scaleY = 5; // Gigante
				centerObj1.alpha = 1;
				game.addChild(centerObj1);
				// Fade out después de 0.5 segundos
				LK.setTimeout(function () {
					tween(centerObj1, {
						alpha: 0
					}, {
						duration: 300,
						easing: tween.linear,
						onFinish: function onFinish() {
							centerObj1.destroy();
						}
					});
				}, 500);
				countdownObjectsFired++;
			} else if (countdownObjectsFired === 1) {
				var obj2 = new CountdownTwo();
				obj2.x = fruitX;
				obj2.y = 2732 + obj2.radius - 120;
				obj2.startY = obj2.y;
				obj2.targetY = 2732 / 2 + 600;
				obj2.state = 'rising';
				obj2.ticks = 0;
				obj2.roundMeta = {
					hasCrossed: false,
					crossedTick: null,
					showScheduled: false,
					showTimeout: null,
					destroyed: false
				};
				fruits.push(obj2);
				roundFruitsQueue.push(obj2);
				game.addChild(obj2);
				// Mostrar "2" centrado y gigante con fade out
				var centerObj2 = new CountdownTwo();
				centerObj2.x = 2048 / 2;
				centerObj2.y = 2732 / 2;
				centerObj2.scaleX = centerObj2.scaleY = 5; // Gigante
				centerObj2.alpha = 1;
				game.addChild(centerObj2);
				// Fade out después de 0.5 segundos
				LK.setTimeout(function () {
					tween(centerObj2, {
						alpha: 0
					}, {
						duration: 300,
						easing: tween.linear,
						onFinish: function onFinish() {
							centerObj2.destroy();
						}
					});
				}, 500);
				countdownObjectsFired++;
			} else if (countdownObjectsFired === 2) {
				var objGo = new CountdownGo();
				objGo.x = fruitX;
				objGo.y = 2732 + objGo.radius - 120;
				objGo.startY = objGo.y;
				objGo.targetY = 2732 / 2 + 600;
				objGo.state = 'rising';
				objGo.ticks = 0;
				objGo.roundMeta = {
					hasCrossed: false,
					crossedTick: null,
					showScheduled: false,
					showTimeout: null,
					destroyed: false
				};
				fruits.push(objGo);
				roundFruitsQueue.push(objGo);
				game.addChild(objGo);
				// Mostrar "Go!" centrado y gigante con fade out
				var centerObjGo = new CountdownGo();
				centerObjGo.x = 2048 / 2;
				centerObjGo.y = 2732 / 2;
				centerObjGo.scaleX = centerObjGo.scaleY = 5; // Gigante
				centerObjGo.alpha = 1;
				game.addChild(centerObjGo);
				// Fade out después de 0.5 segundos
				LK.setTimeout(function () {
					tween(centerObjGo, {
						alpha: 0
					}, {
						duration: 300,
						easing: tween.linear,
						onFinish: function onFinish() {
							centerObjGo.destroy();
						}
					});
				}, 500);
				countdownObjectsFired++;
				// After Go!, wait 2 seconds before launching fruits
				if (typeof goShotTick === "undefined") {
					goShotTick = LK.ticks;
				}
			} else {
				// Wait 1.3 seconds (78 ticks) after Go! before launching fruits
				if (typeof goShotTick !== "undefined" && LK.ticks - goShotTick < 60) {
					return;
				}
				// Después de los tres primeros, dispara frutas normales
				var fruit = new Fruit();
				fruit.x = fruitX;
				fruit.y = 2732 + fruit.radius - 120;
				fruit.startY = fruit.y;
				fruit.targetY = 2732 / 2 + 600;
				fruit.state = 'rising';
				fruit.ticks = 0;
				fruit.roundMeta = {
					hasCrossed: false,
					crossedTick: null,
					showScheduled: false,
					showTimeout: null,
					destroyed: false
				};
				fruits.push(fruit);
				roundFruitsQueue.push(fruit);
				game.addChild(fruit);
			}
			// Asegura que el cañón siempre esté al frente
			if (cannon && cannon.parent) {
				cannon.parent.removeChild(cannon);
				game.addChild(cannon);
			}
			roundBulletsFired++;
			// After Go!, wait 1.3 seconds before next bullet
			if (countdownObjectsFired === 3 && roundBulletsFired === 3) {
				roundNextBulletTick = LK.ticks + 60; // 1.3s wait after Go!
			} else if (roundBulletsFired < 3) {
				// Original timing for countdown objects (1, 2, Go!)
				roundNextBulletTick = LK.ticks + 30; // 0.5s between countdown objects
			} else {
				// Timing between fruits based on stage
				if (currentStage === 1) {
					roundNextBulletTick = LK.ticks + 60; // 1s entre frutas (stage 1)
				} else if (currentStage === 2) {
					roundNextBulletTick = LK.ticks + 30; // 0.5s entre frutas (stage 2)
				} else if (currentStage === 3) {
					// Custom delays for stage 3: first fruit immediately, then 0.5s, 1s, 0.5s
					var fruitNumber = roundBulletsFired - countdownObjectsFired;
					if (fruitNumber === 1) {
						roundNextBulletTick = LK.ticks + 30; // 0.5s delay after first fruit
					} else if (fruitNumber === 2) {
						roundNextBulletTick = LK.ticks + 60; // 1s delay after second fruit  
					} else if (fruitNumber === 3) {
						roundNextBulletTick = LK.ticks + 30; // 0.5s delay after third fruit
					} else {
						roundNextBulletTick = LK.ticks + 30; // Default for any additional fruits
					}
				}
			}
		}
		// When all bullets are fired, round is complete
		if (roundBulletsFired >= roundBullets) {
			roundState = 'complete';
		}
	}
	if (roundState === 'complete') {
		// Round completed - do nothing, no more spawning
	}
	// Mover frutas que suben desde abajo hasta el centro
	for (var i = fruits.length - 1; i >= 0; i--) {
		var fruit = fruits[i];
		if (fruit.state === 'rising') {
			// Cambiar velocidad solo en etapa 2
			var currentFruitSpeed = fruitSpeed;
			if (currentStage === 2) {
				currentFruitSpeed = 40; // velocidad más rápida en etapa 2
			}
			fruit.y -= currentFruitSpeed;
			fruit.ticks++;
			// Escalado según altura (más arriba, más grande)
			var minScale = 1.0;
			var maxScale = 1.25;
			var y0 = 2732 + fruit.radius + 10;
			var y1 = 2732 / 2 + 420;
			var t = (fruit.y - y1) / (y0 - y1);
			if (t < 0) {
				t = 0;
			}
			if (t > 1) {
				t = 1;
			}
			var scale = minScale + (maxScale - minScale) * (1 - t);
			fruit.scaleX = fruit.scaleY = scale;
			// Rotación en la parte de abajo (solo mientras sube)
			if (typeof fruit.rotation === "undefined") {
				fruit.rotation = Math.random() * Math.PI * 2;
			}
			if (typeof fruit.rotationSpeed === "undefined") {
				fruit.rotationSpeed = (Math.random() - 0.5) * 0.08;
			}
			fruit.rotation += fruit.rotationSpeed;
			if (fruit.fruitAsset) {
				fruit.fruitAsset.rotation = fruit.rotation;
			}
			// Cuando cruza la altura objetivo (centro), programar aparición en pantalla superior tras un tiempo proporcional al número de frutas lanzadas
			if (!fruit.roundMeta.hasCrossed && fruit.y <= fruit.targetY) {
				fruit.roundMeta.hasCrossed = true;
				fruit.roundMeta.crossedTick = LK.ticks;
				fruit.visible = false;
				// Cambiar tiempo de espera solo en etapa 2
				var appearDelayMs = 2700; // default 2.7s
				if (currentStage === 2) {
					appearDelayMs = 1000; // 1.5s en etapa 2
				}
				var isCountdownObject = fruit instanceof CountdownOne || fruit instanceof CountdownTwo || fruit instanceof CountdownGo;
				if (!isCountdownObject) {
					fruit.roundMeta.showScheduled = true;
					fruit.roundMeta.showTimeout = LK.setTimeout(function (fruitRef, fruitsArr, iIdx) {
						return function () {
							if (fruitRef.roundMeta.destroyed) {
								return;
							}
							var fruitType = fruitRef.fruitType;
							var x = fruitRef.x;
							// Mark as processed before destroying
							fruitRef.roundMeta.destroyed = true;
							fruitRef.destroy();
							for (var j = 0; j < fruitsArr.length; j++) {
								if (fruitsArr[j] === fruitRef) {
									fruitsArr.splice(j, 1);
									break;
								}
							}
							var fallingFruit = new Fruit();
							if (typeof fruitType === "undefined" || !fruitType) {
								fruitType = fallingFruit.fruitType;
							} else {
								fallingFruit.fruitType = fruitType;
							}
							if (fallingFruit.fruitAsset) {
								fallingFruit.fruitAsset.destroy();
							}
							fallingFruit.fruitAsset = fallingFruit.attachAsset(fallingFruit.fruitType, {
								anchorX: 0.5,
								anchorY: 0.5
							});
							fallingFruit.x = x;
							fallingFruit.y = 2732 / 2 + 420 + 100;
							fallingFruit.startY = fallingFruit.y;
							fallingFruit.state = 'cuttable';
							fallingFruit.ticks = 0;
							fallingFruit.rotation = Math.random() * Math.PI * 2;
							fallingFruit.rotationSpeed = (Math.random() - 0.5) * 0.04;
							fallingFruit.roundMeta = {
								destroyed: false
							};
							fallingFruits.push(fallingFruit);
							roundFruitsActive.push(fallingFruit);
							game.addChild(fallingFruit);
							if (horizontalLine && horizontalLine.parent) {
								horizontalLine.parent.removeChild(horizontalLine);
								game.addChild(horizontalLine);
							}
							if (cannon && cannon.parent) {
								cannon.parent.removeChild(cannon);
								game.addChild(cannon);
							}
						};
					}(fruit, fruits, i), appearDelayMs);
				}
			}
			if (fruit.roundMeta.hasCrossed && fruit.roundMeta.showScheduled) {
				if (fruit.roundMeta.destroyed) {
					if (fruit.roundMeta.showTimeout) {
						LK.clearTimeout(fruit.roundMeta.showTimeout);
						fruit.roundMeta.showTimeout = null;
					}
					if (typeof roundFruitsQueue !== "undefined") {
						for (var j = roundFruitsQueue.length - 1; j >= 0; j--) {
							if (roundFruitsQueue[j] === fruit) {
								roundFruitsQueue.splice(j, 1);
								break;
							}
						}
					}
					fruits.splice(i, 1);
				}
				continue;
			}
		}
	}
	// Mover frutas que suben de nuevo y gestionar zona de corte visual
	// --- Asegura que la línea negra esté sobre los sprites de las frutas en cada frame ---
	if (horizontalLine && horizontalLine.parent) {
		horizontalLine.parent.removeChild(horizontalLine);
		game.addChild(horizontalLine);
	}
	for (var i = fallingFruits.length - 1; i >= 0; i--) {
		var fruit = fallingFruits[i];
		if (!fruit.isActive) {
			continue;
		}
		// Escalado según altura (más arriba, más grande)
		var minScale = 1.0;
		var maxScale = 1.25 * 1.3 * 1.3; //{45} // 60% más grande en la parte superior
		var y0 = 2732 / 2 + 420;
		var y1 = 420;
		var t = (fruit.y - y1) / (y0 - y1);
		if (t < 0) {
			t = 0;
		}
		if (t > 1) {
			t = 1;
		}
		var scale = minScale + (maxScale - minScale) * (1 - t);
		fruit.scaleX = fruit.scaleY = scale;
		// Rotación suave
		if (typeof fruit.rotationSpeed !== "undefined") {
			fruit.rotation += fruit.rotationSpeed;
			if (fruit.fruitAsset) {
				fruit.fruitAsset.rotation = fruit.rotation;
			}
		}
		// Movimiento hacia arriba mientras sea cortable o volando hacia arriba
		if (fruit.state === 'cuttable' || fruit.state === 'flyingup') {
			var topFruitSpeed = fruitSpeed;
			if (currentStage === 2) {
				topFruitSpeed = 30; // velocidad más alta en la segunda etapa
			}
			fruit.y -= topFruitSpeed;
		}
		// --- Animación progresiva del círculo de corte ---
		// El círculo aparece desde el inicio de la subida (cuttable), crece y se difumina progresivamente
		if (fruit.state === 'cuttable') {
			// Si no existe el círculo, crearlo
			if (!fruit.cutZoneCircle) {
				fruit.cutZoneCircle = LK.getAsset('cut_zone', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: fruit.x,
					y: fruit.y,
					alpha: 0.0,
					scaleX: 0.1,
					scaleY: 0.1
				});
				game.addChild(fruit.cutZoneCircle);
				// Asegura que la línea negra esté sobre el círculo de corte pero debajo del cañón
				if (horizontalLine && horizontalLine.parent) {
					horizontalLine.parent.removeChild(horizontalLine);
					game.addChild(horizontalLine);
				}
				// Asegura que el cañón siempre esté al frente
				if (cannon && cannon.parent) {
					cannon.parent.removeChild(cannon);
					game.addChild(cannon);
				}
			}
			// Progresión del círculo: desde que inicia la subida hasta que llega cerca de la parte superior
			var appearT = (y0 - fruit.y) / (y0 - y1);
			if (appearT < 0) {
				appearT = 0;
			}
			if (appearT > 1) {
				appearT = 1;
			}
			var maxScaleZone = 0.85; // Más pequeño, para que quede dentro de la fruta
			var minScaleZone = 0.15;
			var maxAlpha = 0.38; // Más difuminado
			var minAlpha = 0.08;
			var scaleZone = minScaleZone + (maxScaleZone - minScaleZone) * appearT;
			var alphaZone = minAlpha + (maxAlpha - minAlpha) * appearT;
			fruit.cutZoneCircle.scaleX = fruit.cutZoneCircle.scaleY = scaleZone;
			fruit.cutZoneCircle.alpha = alphaZone;
			fruit.cutZoneCircle.x = fruit.x;
			fruit.cutZoneCircle.y = fruit.y;
			// Si la fruta sale por arriba, eliminar círculo y pasar a flyingup
			if (fruit.y < y1) {
				// Si el círculo de corte existe y la fruta no fue cortada, contar como fallada
				if (fruit.cutZoneCircle) {
					fruit.cutZoneCircle.destroy();
					fruit.cutZoneCircle = null;
					if (fruit.isActive && !fruit.isCut) {
						frutasFalladas++;
						frutasGeneradas++;
					}
				}
				fruit.state = 'flyingup';
			}
		} else {
			// Si no está en estado cortable y existe el círculo, destruirlo
			if (fruit.cutZoneCircle) {
				fruit.cutZoneCircle.destroy();
				fruit.cutZoneCircle = null;
			}
		}
		// Si fue cortada, eliminar círculo visual inmediatamente pero mantener la fruta visible
		if (!fruit.isActive && fruit.cutZoneCircle) {
			fruit.cutZoneCircle.destroy();
			fruit.cutZoneCircle = null;
		}
		// Si está cayendo, animar caída
		if (fruit.state === 'dropping') {
			fruit.dropSpeed += 2.5; // gravedad
			fruit.y += fruit.dropSpeed;
			// Escalado decreciente al caer
			fruit.scaleX = fruit.scaleY = Math.max(0.7, fruit.scaleX - 0.01);
			if (fruit.cutZoneCircle) {
				fruit.cutZoneCircle.x = fruit.x;
				fruit.cutZoneCircle.y = fruit.y;
			}
			// Si sale de pantalla, marcar como inactivo pero mantener visible
			if (fruit.y > 2732 + fruit.radius + 20) {
				if (fruit.cutZoneCircle) {
					fruit.cutZoneCircle.destroy();
					fruit.cutZoneCircle = null;
				}
				fruit.isActive = false;
			}
		}
		// Si la fruta sigue subiendo después de la zona de corte y no fue cortada
		// Si la fruta sigue subiendo después de la zona de corte y no fue cortada
		if (fruit.state === 'flyingup') {
			if (currentStage === 3) {
				// Al entrar por primera vez en flyingup, inicia temporizador de espera solo en etapa 3
				if (typeof fruit.waitTicks === "undefined") {
					fruit.waitTicks = 0;
				}
				fruit.waitTicks++;
				// Mantener la fruta visible y estática durante 4 segundos (240 ticks)
				if (fruit.waitTicks < 240) {
					// Mantener posición (puedes dejarlo estático o hacer que suba muy lento)
					// fruit.y -= fruitSpeed * 0.1; // opcional
				} else {
					// Después de 4 segundos, hacer que suba y desaparezca
					fruit.y -= fruitSpeed;
					// Escalado sigue creciendo un poco
					fruit.scaleX = fruit.scaleY = Math.min(maxScale, fruit.scaleX + 0.01);
					// Si sale de pantalla por arriba, destruir inmediatamente
					if (fruit.y < -fruit.radius - 20) {
						if (fruit.cutZoneCircle) {
							fruit.cutZoneCircle.destroy();
							fruit.cutZoneCircle = null;
						}
						fruit.isActive = false;
						// Marcar como destruida para el sistema de ronda
						if (fruit.roundMeta) {
							fruit.roundMeta.destroyed = true;
						}
						// Eliminar de roundFruitsActive si está presente
						if (typeof roundFruitsActive !== "undefined") {
							for (var j = roundFruitsActive.length - 1; j >= 0; j--) {
								if (roundFruitsActive[j] === fruit) {
									roundFruitsActive.splice(j, 1);
									break;
								}
							}
						}
						// Aumentar frutasFalladas y frutasGeneradas solo si la fruta no fue cortada
						if (!fruit.isCut) {
							frutasFalladas++;
							frutasGeneradas++;
						}
						// Destruir la fruta inmediatamente
						fruit.destroy();
						fallingFruits.splice(i, 1);
						continue;
					}
				}
			} else {
				// En otras etapas: comportamiento original sin espera ni modificación
				fruit.y -= fruitSpeed;
				fruit.scaleX = fruit.scaleY = Math.min(maxScale, fruit.scaleX + 0.01);
				if (fruit.y < -fruit.radius - 20) {
					if (fruit.cutZoneCircle) {
						fruit.cutZoneCircle.destroy();
						fruit.cutZoneCircle = null;
					}
					fruit.isActive = false;
					if (fruit.roundMeta) {
						fruit.roundMeta.destroyed = true;
					}
					if (typeof roundFruitsActive !== "undefined") {
						for (var j = roundFruitsActive.length - 1; j >= 0; j--) {
							if (roundFruitsActive[j] === fruit) {
								roundFruitsActive.splice(j, 1);
								break;
							}
						}
					}
					if (!fruit.isCut) {
						frutasFalladas++;
						frutasGeneradas++;
					}
					// Destruir la fruta inmediatamente
					fruit.destroy();
					fallingFruits.splice(i, 1);
					continue;
				}
			}
		}
		// Si la fruta ya fue cortada o salió de pantalla, eliminar
		if (!fruit.isActive || fruit.y > 2732 + fruit.radius + 20 || fruit.y < -fruit.radius - 20) {
			if (fruit.cutZoneCircle) {
				fruit.cutZoneCircle.destroy();
				fruit.cutZoneCircle = null;
			}
			// Marcar como destruida para el sistema de ronda
			if (fruit.roundMeta) {
				fruit.roundMeta.destroyed = true;
			}
			// Eliminar de roundFruitsActive si está presente
			if (typeof roundFruitsActive !== "undefined") {
				for (var j = roundFruitsActive.length - 1; j >= 0; j--) {
					if (roundFruitsActive[j] === fruit) {
						roundFruitsActive.splice(j, 1);
						break;
					}
				}
			}
			// Solo destruir si la fruta está marcada para destrucción
			if (fruit.visible !== false || !fruit.isActive) {
				fruit.destroy();
				fallingFruits.splice(i, 1);
			}
		}
	}
	// Limpiar mitades cortadas que ya terminaron animación
	for (var i = cutFruits.length - 1; i >= 0; i--) {
		var fc = cutFruits[i];
		if (!fc.left || !fc.right) {
			if (fc.destroy) {
				fc.destroy();
			}
			cutFruits.splice(i, 1);
		}
	}
	// Variable para controlar el timeout (debe estar fuera de la función que chequea frutasFalladas)
	if (frutasFalladas >= 5 || frutasGeneradas >= 5 && frutasFalladas < 5) {
		// Mostrar los sprites 1, 2, Go en el centro con fade in/fade out rápido solo una vez, SOLO al inicio del juego
		if ((typeof showCountdownInMiddleDone === "undefined" || !showCountdownInMiddleDone) && LK.ticks < 120) {
			showCountdownInMiddleDone = true;
			var centerX = 2048 / 2;
			var centerY = 2732 / 2;
			var countdownSprites = [{
				cls: CountdownOne,
				delay: 0
			}, {
				cls: CountdownTwo,
				delay: 350
			}, {
				cls: CountdownGo,
				delay: 700
			}];
			for (var idx = 0; idx < countdownSprites.length; idx++) {
				(function (idx) {
					var conf = countdownSprites[idx];
					LK.setTimeout(function () {
						var obj = new conf.cls();
						obj.x = centerX;
						obj.y = centerY;
						obj.alpha = 0;
						game.addChild(obj);
						// Fade in rápido
						tween(obj, {
							alpha: 1
						}, {
							duration: 180,
							easing: tween.cubicOut,
							onFinish: function onFinish() {
								// Fade out rápido
								tween(obj, {
									alpha: 0
								}, {
									duration: 180,
									delay: 180,
									easing: tween.cubicIn,
									onFinish: function onFinish() {
										obj.destroy();
									}
								});
							}
						});
					}, conf.delay);
				})(idx);
			}
		}
		if (!frutasFalladasTimeout) {
			frutasFalladasTimeout = LK.setTimeout(function () {
				for (var i = fruits.length - 1; i >= 0; i--) {
					if (fruits[i]) {
						fruits[i].destroy();
					}
				}
				fruits = [];
				for (var i = fallingFruits.length - 1; i >= 0; i--) {
					if (fallingFruits[i]) {
						fallingFruits[i].destroy();
					}
				}
				fallingFruits = [];
				for (var i = cutFruits.length - 1; i >= 0; i--) {
					if (cutFruits[i]) {
						cutFruits[i].destroy();
					}
				}
				cutFruits = [];
				if (typeof roundFruitsQueue !== "undefined") {
					for (var i = roundFruitsQueue.length - 1; i >= 0; i--) {
						if (roundFruitsQueue[i] && roundFruitsQueue[i].destroy) {
							roundFruitsQueue[i].destroy();
						}
					}
				}
				roundFruitsQueue = [];
				if (typeof roundFruitsActive !== "undefined") {
					for (var i = roundFruitsActive.length - 1; i >= 0; i--) {
						if (roundFruitsActive[i] && roundFruitsActive[i].destroy) {
							roundFruitsActive[i].destroy();
						}
					}
				}
				roundFruitsActive = [];
				// Do not reset round state - game ends here
				frutasFalladas = 0;
				frutasGeneradas = 0;
				updateScore(0);
				frutasFalladasTimeout = null;
				showCountdownInMiddleDone = false;
			}, 2000);
		}
		return;
	}
};
updateScore(0);

===================================================================
--- original.js
+++ change.js
@@ -978,9 +978,9 @@
 					// Después de 4 segundos, hacer que suba y desaparezca
 					fruit.y -= fruitSpeed;
 					// Escalado sigue creciendo un poco
 					fruit.scaleX = fruit.scaleY = Math.min(maxScale, fruit.scaleX + 0.01);
-					// Si sale de pantalla por arriba, marcar como inactiva y eliminar círculo de corte si existe
+					// Si sale de pantalla por arriba, destruir inmediatamente
 					if (fruit.y < -fruit.radius - 20) {
 						if (fruit.cutZoneCircle) {
 							fruit.cutZoneCircle.destroy();
 							fruit.cutZoneCircle = null;
@@ -1003,8 +1003,12 @@
 						if (!fruit.isCut) {
 							frutasFalladas++;
 							frutasGeneradas++;
 						}
+						// Destruir la fruta inmediatamente
+						fruit.destroy();
+						fallingFruits.splice(i, 1);
+						continue;
 					}
 				}
 			} else {
 				// En otras etapas: comportamiento original sin espera ni modificación
@@ -1030,8 +1034,12 @@
 					if (!fruit.isCut) {
 						frutasFalladas++;
 						frutasGeneradas++;
 					}
+					// Destruir la fruta inmediatamente
+					fruit.destroy();
+					fallingFruits.splice(i, 1);
+					continue;
 				}
 			}
 		}
 		// Si la fruta ya fue cortada o salió de pantalla, eliminar