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

/**** 
* Classes
****/ 
// 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 y posición base
	self.init = function (fruitType, x, y) {
		// Mitad izquierda
		self.left = self.attachAsset(fruitType, {
			anchorX: 1,
			anchorY: 0.5,
			scaleX: 0.5,
			x: 0,
			y: 0
		});
		// Mitad derecha
		self.right = self.attachAsset(fruitType, {
			anchorX: 0,
			anchorY: 0.5,
			scaleX: 0.5,
			x: 0,
			y: 0
		});
		self.x = x;
		self.y = y;
		self.left.rotation = 0;
		self.right.rotation = 0;
	};
	// Animación de separación
	self.animate = function (_onFinish) {
		tween(self.left, {
			x: -80,
			rotation: -0.7
		}, {
			duration: 500,
			easing: tween.cubicOut
		});
		tween(self.right, {
			x: 80,
			rotation: 0.7
		}, {
			duration: 500,
			easing: tween.cubicOut,
			onFinish: function onFinish() {
				if (_onFinish) {
					_onFinish();
				}
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Sonido de corte
// Efecto de corte (línea)
// Frutas: Usamos formas básicas para representar diferentes frutas
// Eliminado: zona de corte y línea de corte. Ahora el círculo de corte es dinámico y aparece solo cuando la fruta puede ser cortada.
// Score
var scoreTxt = new Text2('0', {
	size: 120,
	fill: "#222"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Contador de frutas generadas
var frutasGeneradas = 0;
var frutasGeneradasTxt = new Text2('Frutas: 0', {
	size: 80,
	fill: "#fff"
});
frutasGeneradasTxt.anchor.set(0.5, 0);
frutasGeneradasTxt.y = 130; // Debajo del score
LK.gui.top.addChild(frutasGeneradasTxt);
// Variables globales
var frutasFalladas = 0; // Contador de frutas falladas
var fruits = []; // Frutas lanzadas desde abajo
var fallingFruits = []; // Frutas que caen desde arriba
var cutFruits = []; // Frutas cortadas (animación)
var frutasFalladasTimeout = null; // Timeout para reinicio tras 5 fallos
// --- BLOQUE DE BALAS POR RONDA ---
var roundBullets = 5; // Balas por ronda
var bulletsFired = 0; // Contador de balas disparadas en la ronda
var bulletInterval = 60; // 1 segundo entre balas (60 ticks)
var bulletTimer = 0; // Temporizador para disparo de balas
var roundActive = true; // Si la ronda está activa
var roundDelay = 120; // Tiempo de espera entre rondas (2 segundos)
var roundDelayTimer = 0; // Temporizador para delay entre rondas
var fruitSpeed = 22; // velocidad de subida/bajada
var fruitTimer = 0;
// Obtener el radio del asset de zona de corte (cut_zone) usando LK.getAsset
var cutZoneAsset = LK.getAsset('cut_zone', {
	anchorX: 0.5,
	anchorY: 0.5
});
var cutZoneRadius = cutZoneAsset.width / 2;
cutZoneAsset.destroy(); // No lo necesitamos en pantalla, solo para el tamaño
var canCut = true; // Para evitar múltiples cortes por fruta
var lastTouchTick = -100;
// Actualiza score
function updateScore(val) {
	LK.setScore(val);
	scoreTxt.setText(val);
}
// Nueva lógica de corte: el corte se detecta solo cuando la fruta está en la zona de corte visual (círculo blanco animado).
function tryCutFruit(x, y) {
	// Solo permite un corte por tick
	if (!canCut) {
		return;
	}
	canCut = false;
	lastTouchTick = LK.ticks;
	// Buscar fruta que esté en estado 'cuttable', activa, y que el toque esté sobre la fruta
	for (var i = 0; i < fallingFruits.length; i++) {
		var fruit = fallingFruits[i];
		if (!fruit.isActive) {
			continue;
		}
		// Solo permite cortar si la fruta está en la zona de corte (cuttable) y el toque está sobre la fruta
		if (fruit.state === 'cuttable') {
			// Verifica si el toque está sobre la fruta (dentro del radio de la fruta)
			var dx = x - fruit.x;
			var dy = y - fruit.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist <= fruit.radius * fruit.scaleX) {
				// Cortar fruta
				fruit.cut();
				// Destruir inmediatamente el círculo de corte si existe
				if (fruit.cutZoneCircle) {
					fruit.cutZoneCircle.destroy();
					fruit.cutZoneCircle = null;
				}
				LK.getSound('cut').play();
				// Animación de mitades
				var fruitCut = new FruitCut();
				fruitCut.init(fruit.fruitType, fruit.x, fruit.y);
				game.addChild(fruitCut);
				fruitCut.animate(function () {
					fruitCut.destroy();
				});
				cutFruits.push(fruitCut);
				frutasGeneradas++;
				frutasGeneradasTxt.setText('Frutas: ' + frutasGeneradas);
				updateScore(LK.getScore() + 1);
				return;
			}
		}
	}
}
// Input: solo touch/click
game.down = function (x, y, obj) {
	// Solo intenta cortar si hay fruta cortable y el toque es sobre la fruta
	tryCutFruit(x, y);
};
game.up = function (x, y, obj) {};
game.move = function (x, y, obj) {};
// 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 = 5;
		roundFruitsQueue = [];
		roundFruitsActive = [];
		roundNextBulletTick = LK.ticks + 30; // primer disparo tras 0.5s
		roundBulletsFired = 0;
		roundDelayBetweenRounds = 120; // 2s entre rondas
		roundDelayTicks = 0;
	}
	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;
		roundState = 'spawning';
	}
	if (roundState === 'spawning') {
		// Disparar una fruta cada 1s hasta 5
		if (roundBulletsFired < roundBullets && LK.ticks >= roundNextBulletTick) {
			// Crear fruta y ponerla en la cola de espera
			var fruit = new Fruit();
			var margin = 180;
			fruit.x = margin + Math.random() * (2048 - 2 * margin);
			fruit.y = 2732 + fruit.radius + 10;
			fruit.startY = fruit.y;
			fruit.targetY = 2732 / 2 + 420;
			fruit.state = 'rising';
			fruit.ticks = 0;
			fruit.roundMeta = {
				// Para tracking de ciclo
				hasCrossed: false,
				crossedTick: null,
				showScheduled: false,
				showTimeout: null,
				destroyed: false
			};
			fruits.push(fruit);
			roundFruitsQueue.push(fruit);
			game.addChild(fruit);
			roundBulletsFired++;
			// El contador de frutas generadas solo se incrementa cuando se corta o se pierde una fruta, no aquí.
			roundNextBulletTick = LK.ticks + 60; // 1s entre balas
		}
		// Cuando todas las balas han sido disparadas y ya no quedan frutas activas, pasar a siguiente estado
		// (pero solo cuando todas las frutas hayan sido destruidas o salidas de pantalla)
		var allGone = true;
		for (var i = 0; i < roundFruitsQueue.length; i++) {
			if (!roundFruitsQueue[i].roundMeta.destroyed) {
				allGone = false;
				break;
			}
		}
		for (var i = 0; i < roundFruitsActive.length; i++) {
			if (!roundFruitsActive[i].roundMeta.destroyed) {
				allGone = false;
				break;
			}
		}
		if (roundBulletsFired >= roundBullets && allGone) {
			roundState = 'waitingFruits';
			roundDelayTicks = 0;
		}
	}
	if (roundState === 'waitingFruits') {
		// Espera 2s antes de reiniciar la ronda
		roundDelayTicks++;
		if (roundDelayTicks >= roundDelayBetweenRounds) {
			// Limpiar arrays de frutas activas y en cola antes de reiniciar la ronda
			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 = [];
			roundFruitsQueue = [];
			roundFruitsActive = [];
			roundState = 'waiting';
		}
	}
	// 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') {
			fruit.y -= fruitSpeed;
			fruit.ticks++;
			// 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;
				// El tiempo de espera es igual a 1s * cantidad de frutas lanzadas en la ronda
				var fruitsInRound = roundBullets;
				var appearDelayMs = fruitsInRound * 1000; // 1s por fruta lanzada
				fruit.roundMeta.showScheduled = true;
				fruit.roundMeta.showTimeout = LK.setTimeout(function (fruitRef, fruitsArr, iIdx) {
					return function () {
						// Si la fruta ya fue destruida antes del tiempo, no hacer nada
						if (fruitRef.roundMeta.destroyed) {
							return;
						}
						// Eliminar de fruits[] y crear en pantalla superior
						var fruitType = fruitRef.fruitType;
						var x = fruitRef.x;
						// Eliminar fruta oculta
						fruitRef.destroy();
						for (var j = 0; j < fruitsArr.length; j++) {
							if (fruitsArr[j] === fruitRef) {
								fruitsArr.splice(j, 1);
								break;
							}
						}
						// Crear fruta en pantalla superior
						var fallingFruit = new Fruit();
						fallingFruit.fruitType = fruitType;
						fallingFruit.fruitAsset.destroy();
						fallingFruit.fruitAsset = fallingFruit.attachAsset(fruitType, {
							anchorX: 0.5,
							anchorY: 0.5
						});
						fallingFruit.x = x;
						fallingFruit.y = 2732 / 2 + 420;
						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);
					};
				}(fruit, fruits, i), appearDelayMs);
			}
			// Si la fruta está oculta y esperando, no hacer nada más
			if (fruit.roundMeta.hasCrossed && fruit.roundMeta.showScheduled) {
				// Si la fruta fue destruida antes de los 7s, cancelar timeout y limpiar
				if (fruit.roundMeta.destroyed) {
					if (fruit.roundMeta.showTimeout) {
						LK.clearTimeout(fruit.roundMeta.showTimeout);
						fruit.roundMeta.showTimeout = null;
					}
					// Eliminar de roundFruitsQueue si está presente
					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;
			}
			// Si la fruta sale de pantalla antes de cruzar, eliminar y marcar como destruida
			if (fruit.y < -fruit.radius - 20) {
				fruit.roundMeta.destroyed = true;
				if (fruit.roundMeta.showTimeout) {
					LK.clearTimeout(fruit.roundMeta.showTimeout);
					fruit.roundMeta.showTimeout = null;
				}
				// Eliminar de roundFruitsQueue si está presente
				if (typeof roundFruitsQueue !== "undefined") {
					for (var j = roundFruitsQueue.length - 1; j >= 0; j--) {
						if (roundFruitsQueue[j] === fruit) {
							roundFruitsQueue.splice(j, 1);
							break;
						}
					}
				}
				// Aumentar frutasFalladas si la fruta se perdió antes de aparecer
				frutasFalladas++;
				frutasGeneradas++;
				frutasGeneradasTxt.setText('Frutas: ' + frutasGeneradas);
				fruit.destroy();
				fruits.splice(i, 1);
			}
		}
	}
	// Mover frutas que suben de nuevo y gestionar zona de corte visual
	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;
		var y0 = 2732 / 2 + 420;
		var y1 = 420;
		var t = (y0 - fruit.y) / (y0 - y1);
		if (t < 0) {
			t = 0;
		}
		if (t > 1) {
			t = 1;
		}
		var scale = minScale + (maxScale - minScale) * 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') {
			fruit.y -= fruitSpeed;
		}
		// --- 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);
			}
			// 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++;
						frutasGeneradasTxt.setText('Frutas: ' + 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
		if (fruit.state === 'flyingup') {
			// Al entrar por primera vez en flyingup, inicia temporizador de espera
			if (typeof fruit.waitTicks === "undefined") {
				fruit.waitTicks = 0;
			}
			fruit.waitTicks++;
			// Mantener la fruta visible y estática durante 7 segundos (420 ticks)
			if (fruit.waitTicks < 420) {
				// Mantener posición (opcional: podrías hacer que siga subiendo lentamente)
				// fruit.y -= fruitSpeed * 0.1;
			} else {
				// Después de 7 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
				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++;
						frutasGeneradasTxt.setText('Frutas: ' + frutasGeneradas);
					}
				}
			}
		}
		// 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;
					}
				}
			}
			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)
	var frutasFalladasTimeout = null;
	// En el lugar donde chequeas las frutas falladas:
	if (frutasFalladas >= 5) {
		if (!frutasFalladasTimeout) {
			console.log('Timeout iniciado para reiniciar juego en 2 segundos');
			frutasFalladasTimeout = setTimeout(function () {
				console.log('Reiniciando juego ahora');
				// Limpiar arrays y destruir objetos
				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 = [];
				// Reset variables de ronda y score
				roundState = 'waiting';
				roundBulletsFired = 0;
				roundNextBulletTick = LK.ticks; // O la variable correcta de ticks
				roundDelayTicks = 0;
				frutasFalladas = 0;
				frutasGeneradas = 0;
				frutasGeneradasTxt.setText('Frutas: 0');
				updateScore(0);
				frutasFalladasTimeout = null; // Resetear el timeout para poder reiniciar de nuevo
			}, 2000);
		}
		// Detener lógica siguiente mientras esperamos reinicio
		return;
	}
};
// Inicializar score
updateScore(0);

===================================================================
--- original.js
+++ change.js
@@ -22,9 +22,11 @@
 	self.isCut = false;
 	self.isActive = true; // Si está en juego
 	// Para saber si ya fue cortada
 	self.cut = function () {
-		if (self.isCut) return;
+		if (self.isCut) {
+			return;
+		}
 		self.isCut = true;
 		self.isActive = false;
 		self.visible = false;
 	};
@@ -71,9 +73,11 @@
 		}, {
 			duration: 500,
 			easing: tween.cubicOut,
 			onFinish: function onFinish() {
-				if (_onFinish) _onFinish();
+				if (_onFinish) {
+					_onFinish();
+				}
 			}
 		});
 	};
 	return self;
@@ -141,15 +145,19 @@
 }
 // Nueva lógica de corte: el corte se detecta solo cuando la fruta está en la zona de corte visual (círculo blanco animado).
 function tryCutFruit(x, y) {
 	// Solo permite un corte por tick
-	if (!canCut) return;
+	if (!canCut) {
+		return;
+	}
 	canCut = false;
 	lastTouchTick = LK.ticks;
 	// Buscar fruta que esté en estado 'cuttable', activa, y que el toque esté sobre la fruta
 	for (var i = 0; i < fallingFruits.length; i++) {
 		var fruit = fallingFruits[i];
-		if (!fruit.isActive) continue;
+		if (!fruit.isActive) {
+			continue;
+		}
 		// Solo permite cortar si la fruta está en la zona de corte (cuttable) y el toque está sobre la fruta
 		if (fruit.state === 'cuttable') {
 			// Verifica si el toque está sobre la fruta (dentro del radio de la fruta)
 			var dx = x - fruit.x;
@@ -189,9 +197,11 @@
 game.move = function (x, y, obj) {};
 // Main update
 game.update = function () {
 	// Permitir corte nuevamente tras 6 ticks (~100ms)
-	if (!canCut && LK.ticks - lastTouchTick > 6) canCut = true;
+	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';
@@ -205,29 +215,39 @@
 	}
 	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();
+			if (fruits[i]) {
+				fruits[i].destroy();
+			}
 		}
 		fruits = [];
 		for (var i = fallingFruits.length - 1; i >= 0; i--) {
-			if (fallingFruits[i]) fallingFruits[i].destroy();
+			if (fallingFruits[i]) {
+				fallingFruits[i].destroy();
+			}
 		}
 		fallingFruits = [];
 		for (var i = cutFruits.length - 1; i >= 0; i--) {
-			if (cutFruits[i]) cutFruits[i].destroy();
+			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();
+				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();
+				if (roundFruitsActive[i] && roundFruitsActive[i].destroy) {
+					roundFruitsActive[i].destroy();
+				}
 			}
 		}
 		roundFruitsActive = [];
 		// Reset meta de ronda
@@ -328,9 +348,11 @@
 				fruit.roundMeta.showScheduled = true;
 				fruit.roundMeta.showTimeout = LK.setTimeout(function (fruitRef, fruitsArr, iIdx) {
 					return function () {
 						// Si la fruta ya fue destruida antes del tiempo, no hacer nada
-						if (fruitRef.roundMeta.destroyed) return;
+						if (fruitRef.roundMeta.destroyed) {
+							return;
+						}
 						// Eliminar de fruits[] y crear en pantalla superior
 						var fruitType = fruitRef.fruitType;
 						var x = fruitRef.x;
 						// Eliminar fruta oculta
@@ -413,23 +435,31 @@
 	}
 	// Mover frutas que suben de nuevo y gestionar zona de corte visual
 	for (var i = fallingFruits.length - 1; i >= 0; i--) {
 		var fruit = fallingFruits[i];
-		if (!fruit.isActive) continue;
+		if (!fruit.isActive) {
+			continue;
+		}
 		// Escalado según altura (más arriba, más grande)
 		var minScale = 1.0;
 		var maxScale = 1.25;
 		var y0 = 2732 / 2 + 420;
 		var y1 = 420;
 		var t = (y0 - fruit.y) / (y0 - y1);
-		if (t < 0) t = 0;
-		if (t > 1) t = 1;
+		if (t < 0) {
+			t = 0;
+		}
+		if (t > 1) {
+			t = 1;
+		}
 		var scale = minScale + (maxScale - minScale) * 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;
+			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') {
 			fruit.y -= fruitSpeed;
@@ -451,10 +481,14 @@
 				game.addChild(fruit.cutZoneCircle);
 			}
 			// 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;
+			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;
@@ -580,57 +614,70 @@
 	// 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();
+			if (fc.destroy) {
+				fc.destroy();
+			}
 			cutFruits.splice(i, 1);
 		}
 	}
-	// Si frutasFalladas llega a 5, espera 2 segundos y reinicia el juego y todas las variables relevantes
+	// Variable para controlar el timeout (debe estar fuera de la función que chequea frutasFalladas)
+	var frutasFalladasTimeout = null;
+	// En el lugar donde chequeas las frutas falladas:
 	if (frutasFalladas >= 5) {
-		if (typeof frutasFalladasTimeout === "undefined" || !frutasFalladasTimeout) {
-			// Solo programar el timeout una vez
-			frutasFalladasTimeout = LK.setTimeout(function () {
+		if (!frutasFalladasTimeout) {
+			console.log('Timeout iniciado para reiniciar juego en 2 segundos');
+			frutasFalladasTimeout = setTimeout(function () {
+				console.log('Reiniciando juego ahora');
 				// Limpiar arrays y destruir objetos
 				for (var i = fruits.length - 1; i >= 0; i--) {
-					if (fruits[i]) fruits[i].destroy();
+					if (fruits[i]) {
+						fruits[i].destroy();
+					}
 				}
 				fruits = [];
 				for (var i = fallingFruits.length - 1; i >= 0; i--) {
-					if (fallingFruits[i]) fallingFruits[i].destroy();
+					if (fallingFruits[i]) {
+						fallingFruits[i].destroy();
+					}
 				}
 				fallingFruits = [];
 				for (var i = cutFruits.length - 1; i >= 0; i--) {
-					if (cutFruits[i]) cutFruits[i].destroy();
+					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();
+						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();
+						if (roundFruitsActive[i] && roundFruitsActive[i].destroy) {
+							roundFruitsActive[i].destroy();
+						}
 					}
 				}
 				roundFruitsActive = [];
 				// Reset variables de ronda y score
 				roundState = 'waiting';
 				roundBulletsFired = 0;
-				roundNextBulletTick = LK.ticks;
+				roundNextBulletTick = LK.ticks; // O la variable correcta de ticks
 				roundDelayTicks = 0;
 				frutasFalladas = 0;
 				frutasGeneradas = 0;
 				frutasGeneradasTxt.setText('Frutas: 0');
 				updateScore(0);
-				frutasFalladasTimeout = null;
-				// Forzar el reinicio de la ronda inmediatamente
-				// (el siguiente update pasará a 'spawning' por roundState = 'waiting')
+				frutasFalladasTimeout = null; // Resetear el timeout para poder reiniciar de nuevo
 			}, 2000);
 		}
-		// Detener el avance de la lógica de ronda mientras esperamos el reinicio
+		// Detener lógica siguiente mientras esperamos reinicio
 		return;
 	}
 };
 // Inicializar score