/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	language: "es"
});

/**** 
* Classes
****/ 
var GameButton = Container.expand(function (text, callback) {
	var self = Container.call(this);
	self.callback = callback;
	self.isEnabled = true;
	self.bg = self.attachAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.text = new Text2(text, {
		size: 40,
		fill: 0xFFFFFF
	});
	self.text.anchor.set(0.5, 0.5);
	self.addChild(self.text);
	self.setEnabled = function (enabled) {
		self.isEnabled = enabled;
		self.alpha = enabled ? 1.0 : 0.5;
	};
	self.down = function (x, y, obj) {
		if (self.isEnabled && self.callback) {
			self.callback();
		}
	};
	return self;
});
var Player = Container.expand(function (playerNumber, color) {
	var self = Container.call(this);
	self.playerNumber = playerNumber;
	self.maxHealth = 3;
	self.health = self.maxHealth;
	self.items = [];
	self.isAlive = true;
	var playerGraphics = self.attachAsset(playerNumber === 1 ? 'player1' : 'player2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var healthBarBg = self.attachAsset('healthBar', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -150,
		tint: 0x660000
	});
	self.healthBar = self.attachAsset('healthBar', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -150
	});
	self.nameText = new Text2('Jugador ' + playerNumber, {
		size: 40,
		fill: 0xFFFFFF
	});
	self.nameText.anchor.set(0.5, 0.5);
	self.nameText.y = -200;
	self.addChild(self.nameText);
	self.healthText = new Text2(self.health + '/' + self.maxHealth, {
		size: 30,
		fill: 0xFFFFFF
	});
	self.healthText.anchor.set(0.5, 0.5);
	self.healthText.y = -120;
	self.addChild(self.healthText);
	self.updateHealth = function () {
		var healthPercent = self.health / self.maxHealth;
		self.healthBar.scaleX = healthPercent;
		self.healthText.setText(self.health + '/' + self.maxHealth);
		if (self.health <= 0) {
			self.isAlive = false;
			self.alpha = 0.5;
		}
	};
	self.takeDamage = function () {
		self.health = Math.max(0, self.health - 1);
		self.updateHealth();
		// Flash red
		tween(self, {
			tint: 0xFF0000
		}, {
			duration: 200,
			onFinish: function onFinish() {
				tween(self, {
					tint: 0xFFFFFF
				}, {
					duration: 200
				});
			}
		});
	};
	self.heal = function () {
		self.health = Math.min(self.maxHealth, self.health + 1);
		self.updateHealth();
		// Flash green
		tween(self, {
			tint: 0x00FF00
		}, {
			duration: 200,
			onFinish: function onFinish() {
				tween(self, {
					tint: 0xFFFFFF
				}, {
					duration: 200
				});
			}
		});
	};
	return self;
});
var Revolver = Container.expand(function () {
	var self = Container.call(this);
	self.chambers = [];
	self.currentChamber = 0;
	self.totalChambers = 6;
	self.isRevealed = false;
	var revolverGraphics = self.attachAsset('revolver', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.chamberIndicators = [];
	for (var i = 0; i < self.totalChambers; i++) {
		var indicator = self.attachAsset('blank', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: (i - 2.5) * 50,
			y: -120
		});
		self.chamberIndicators.push(indicator);
	}
	self.loadChambers = function (liveRounds, blanks) {
		self.chambers = [];
		self.currentChamber = 0;
		// Add live rounds
		for (var i = 0; i < liveRounds; i++) {
			self.chambers.push(true);
		}
		// Add blanks
		for (var i = 0; i < blanks; i++) {
			self.chambers.push(false);
		}
		// Shuffle chambers
		for (var i = self.chambers.length - 1; i > 0; i--) {
			var j = Math.floor(Math.random() * (i + 1));
			var temp = self.chambers[i];
			self.chambers[i] = self.chambers[j];
			self.chambers[j] = temp;
		}
		self.updateDisplay();
	};
	self.updateDisplay = function () {
		for (var i = 0; i < self.totalChambers; i++) {
			if (i < self.chambers.length) {
				if (self.isRevealed || i < self.currentChamber) {
					if (i < self.chambers.length && self.chambers[i]) {
						self.chamberIndicators[i].tint = 0xFFD700; // Gold for live
					} else {
						self.chamberIndicators[i].tint = 0x888888; // Gray for blank
					}
				} else {
					self.chamberIndicators[i].tint = 0x444444; // Dark for unknown
				}
				if (i === self.currentChamber) {
					self.chamberIndicators[i].scaleX = 1.5;
					self.chamberIndicators[i].scaleY = 1.5;
				} else {
					self.chamberIndicators[i].scaleX = 1;
					self.chamberIndicators[i].scaleY = 1;
				}
			} else {
				self.chamberIndicators[i].tint = 0x222222; // Very dark for empty
				self.chamberIndicators[i].scaleX = 1;
				self.chamberIndicators[i].scaleY = 1;
			}
		}
	};
	self.fire = function () {
		if (self.currentChamber >= self.chambers.length) {
			return null; // Empty chamber
		}
		var isLive = self.chambers[self.currentChamber];
		self.currentChamber++;
		self.updateDisplay();
		// Animate rotation
		tween(revolverGraphics, {
			rotation: revolverGraphics.rotation + Math.PI / 3
		}, {
			duration: 300,
			easing: tween.easeOut
		});
		return isLive;
	};
	self.peekNext = function () {
		if (self.currentChamber >= self.chambers.length) {
			return null;
		}
		return self.chambers[self.currentChamber];
	};
	self.getRemainingRounds = function () {
		var live = 0;
		var blank = 0;
		for (var i = self.currentChamber; i < self.chambers.length; i++) {
			if (self.chambers[i]) {
				live++;
			} else {
				blank++;
			}
		}
		return {
			live: live,
			blank: blank
		};
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state
var currentPlayer = 1;
var gamePhase = 'menu'; // menu, setup, playing, gameover
var gameMode = 'pvp'; // pvp, ai
var round = 1;
var player1, player2, revolver;
var buttons = [];
var infoText, roundText, turnText;
var playButton, playAIButton;
// Language system
var currentLanguage = storage.language || 'es';
var texts = {
	es: {
		player: 'Jugador',
		ai: 'IA',
		round: 'Ronda',
		turn: 'Turno del',
		chooseAction: 'Elige tu acción',
		playTwoPlayers: 'JUGAR (2 JUGADORES)',
		playAgainstAI: 'JUGAR CONTRA IA',
		settings: 'AJUSTES',
		shootOpponent: 'Disparar al Oponente',
		shootSelf: 'Dispararse a Sí Mismo',
		welcome: '¡Bienvenido al Duelo de Ruleta Rusa!',
		magnifyingGlass: 'Ver próxima bala',
		handcuffs: 'Saltar turno del oponente',
		cigarettes: 'Restaurar 1 de salud',
		chamberEmpty: 'La recámara está vacía',
		nextBullet: 'La próxima bala es:',
		real: 'REAL',
		blank: 'DE FOGUEO',
		opponentSkip: 'El oponente saltará su próximo turno',
		healthRestored: 'Salud restaurada',
		bang: '¡BANG!',
		opponentHit: '¡Oponente impactado!',
		click: '*Clic*',
		blankRound: 'Bala de fogueo',
		emptyChamer: 'Recámara vacía',
		shotSelf: '¡Te disparaste a ti mismo!',
		blankContinue: '¡De fogueo! Continúa tu turno',
		handcuffsUsed: 'Esposas usadas - el oponente salta su turno',
		revolverEmpty: 'Revólver vacío - Nueva ronda comenzando...',
		remaining: 'restantes',
		aiShootSelf: 'IA decide dispararse a sí misma...',
		aiShootOpponent: 'IA decide disparar al oponente...',
		wins: 'Gana!',
		gameOver: 'Juego Terminado',
		sound: 'SONIDO',
		music: 'MÚSICA',
		close: 'CERRAR',
		language: 'IDIOMA',
		on: 'ON',
		off: 'OFF',
		spanish: 'ESPAÑOL',
		english: 'INGLÉS',
		italian: 'ITALIANO',
		portuguese: 'PORTUGUÉS'
	},
	en: {
		player: 'Player',
		ai: 'AI',
		round: 'Round',
		turn: 'Turn of',
		chooseAction: 'Choose your action',
		playTwoPlayers: 'PLAY (2 PLAYERS)',
		playAgainstAI: 'PLAY AGAINST AI',
		settings: 'SETTINGS',
		shootOpponent: 'Shoot Opponent',
		shootSelf: 'Shoot Self',
		welcome: 'Welcome to Russian Roulette Duel!',
		magnifyingGlass: 'See next bullet',
		handcuffs: 'Skip opponent turn',
		cigarettes: 'Restore 1 health',
		chamberEmpty: 'Chamber is empty',
		nextBullet: 'Next bullet is:',
		real: 'LIVE',
		blank: 'BLANK',
		opponentSkip: 'Opponent will skip their next turn',
		healthRestored: 'Health restored',
		bang: 'BANG!',
		opponentHit: 'Opponent hit!',
		click: '*Click*',
		blankRound: 'Blank round',
		emptyChamer: 'Empty chamber',
		shotSelf: 'You shot yourself!',
		blankContinue: 'Blank! Continue your turn',
		handcuffsUsed: 'Handcuffs used - opponent skips turn',
		revolverEmpty: 'Revolver empty - New round starting...',
		remaining: 'remaining',
		aiShootSelf: 'AI decides to shoot itself...',
		aiShootOpponent: 'AI decides to shoot opponent...',
		wins: 'Wins!',
		gameOver: 'Game Over',
		sound: 'SOUND',
		music: 'MUSIC',
		close: 'CLOSE',
		language: 'LANGUAGE',
		on: 'ON',
		off: 'OFF',
		spanish: 'SPANISH',
		english: 'ENGLISH',
		italian: 'ITALIAN',
		portuguese: 'PORTUGUESE'
	},
	it: {
		player: 'Giocatore',
		ai: 'IA',
		round: 'Round',
		turn: 'Turno di',
		chooseAction: 'Scegli la tua azione',
		playTwoPlayers: 'GIOCA (2 GIOCATORI)',
		playAgainstAI: 'GIOCA CONTRO IA',
		settings: 'IMPOSTAZIONI',
		shootOpponent: 'Spara all\'Avversario',
		shootSelf: 'Sparati',
		welcome: 'Benvenuto al Duello di Roulette Russa!',
		magnifyingGlass: 'Vedi prossimo proiettile',
		handcuffs: 'Salta turno avversario',
		cigarettes: 'Ripristina 1 salute',
		chamberEmpty: 'La camera è vuota',
		nextBullet: 'Il prossimo proiettile è:',
		real: 'VERO',
		blank: 'A SALVE',
		opponentSkip: 'L\'avversario salterà il suo prossimo turno',
		healthRestored: 'Salute ripristinata',
		bang: 'BANG!',
		opponentHit: 'Avversario colpito!',
		click: '*Click*',
		blankRound: 'Colpo a salve',
		emptyChamer: 'Camera vuota',
		shotSelf: 'Ti sei sparato!',
		blankContinue: 'A salve! Continua il tuo turno',
		handcuffsUsed: 'Manette usate - l\'avversario salta il turno',
		revolverEmpty: 'Revolver vuoto - Inizia nuovo round...',
		remaining: 'rimanenti',
		aiShootSelf: 'IA decide di spararsi...',
		aiShootOpponent: 'IA decide di sparare all\'avversario...',
		wins: 'Vince!',
		gameOver: 'Gioco Finito',
		sound: 'SUONO',
		music: 'MUSICA',
		close: 'CHIUDI',
		language: 'LINGUA',
		on: 'ON',
		off: 'OFF',
		spanish: 'SPAGNOLO',
		english: 'INGLESE',
		italian: 'ITALIANO',
		portuguese: 'PORTOGHESE'
	},
	pt: {
		player: 'Jogador',
		ai: 'IA',
		round: 'Rodada',
		turn: 'Turno do',
		chooseAction: 'Escolha sua ação',
		playTwoPlayers: 'JOGAR (2 JOGADORES)',
		playAgainstAI: 'JOGAR CONTRA IA',
		settings: 'CONFIGURAÇÕES',
		shootOpponent: 'Atirar no Oponente',
		shootSelf: 'Atirar em Si Mesmo',
		welcome: 'Bem-vindo ao Duelo de Roleta Russa!',
		magnifyingGlass: 'Ver próxima bala',
		handcuffs: 'Pular turno do oponente',
		cigarettes: 'Restaurar 1 de saúde',
		chamberEmpty: 'A câmara está vazia',
		nextBullet: 'A próxima bala é:',
		real: 'REAL',
		blank: 'DE FESTIM',
		opponentSkip: 'O oponente pulará seu próximo turno',
		healthRestored: 'Saúde restaurada',
		bang: 'BANG!',
		opponentHit: 'Oponente atingido!',
		click: '*Clique*',
		blankRound: 'Tiro de festim',
		emptyChamer: 'Câmara vazia',
		shotSelf: 'Você atirou em si mesmo!',
		blankContinue: 'De festim! Continue seu turno',
		handcuffsUsed: 'Algemas usadas - oponente pula turno',
		revolverEmpty: 'Revólver vazio - Nova rodada começando...',
		remaining: 'restantes',
		aiShootSelf: 'IA decide atirar em si mesma...',
		aiShootOpponent: 'IA decide atirar no oponente...',
		wins: 'Vence!',
		gameOver: 'Fim de Jogo',
		sound: 'SOM',
		music: 'MÚSICA',
		close: 'FECHAR',
		language: 'IDIOMA',
		on: 'LIGADO',
		off: 'DESLIGADO',
		spanish: 'ESPANHOL',
		english: 'INGLÊS',
		italian: 'ITALIANO',
		portuguese: 'PORTUGUÊS'
	}
};
function getText(key) {
	return texts[currentLanguage][key] || key;
}
function changeLanguage(newLanguage) {
	currentLanguage = newLanguage;
	storage.language = newLanguage;
	updateAllTexts();
}
function updateAllTexts() {
	// Update UI texts
	if (roundText) roundText.setText(getText('round') + ' ' + round);
	if (turnText) {
		var playerName = gameMode === 'ai' && currentPlayer === 2 ? getText('ai') : getText('player') + ' ' + currentPlayer;
		turnText.setText(getText('turn') + ' ' + playerName);
	}
	if (infoText && gamePhase === 'menu') {
		infoText.setText(getText('welcome'));
	}
	// Update player names
	if (player1 && player1.nameText) {
		player1.nameText.setText(getText('player') + ' 1');
	}
	if (player2 && player2.nameText) {
		var p2Name = gameMode === 'ai' ? getText('ai') : getText('player') + ' 2';
		player2.nameText.setText(p2Name);
	}
	// Update button texts
	if (playButton && playButton.text) {
		playButton.text.setText(getText('playTwoPlayers'));
	}
	if (playAIButton && playAIButton.text) {
		playAIButton.text.setText(getText('playAgainstAI'));
	}
	if (shootOpponentButton && shootOpponentButton.text) {
		shootOpponentButton.text.setText(getText('shootOpponent'));
	}
	if (shootSelfButton && shootSelfButton.text) {
		shootSelfButton.text.setText(getText('shootSelf'));
	}
	// Update item descriptions
	itemDescriptions = {
		'magnifying_glass': getText('magnifyingGlass'),
		'handcuffs': getText('handcuffs'),
		'cigarettes': getText('cigarettes')
	};
}
// Available items
var availableItems = ['magnifying_glass', 'handcuffs', 'cigarettes'];
var itemDescriptions = {
	'magnifying_glass': 'Ver próxima bala',
	'handcuffs': 'Saltar turno del oponente',
	'cigarettes': 'Restaurar 1 de salud'
};
// Initialize players
player1 = game.addChild(new Player(1));
player1.x = 512;
player1.y = 1800;
player2 = game.addChild(new Player(2));
player2.x = 1536;
player2.y = 1800;
// Initialize revolver
revolver = game.addChild(new Revolver());
revolver.x = 1024;
revolver.y = 1000;
// UI Text
roundText = new Text2(getText('round') + ' 1', {
	size: 60,
	fill: 0xFFFFFF
});
roundText.anchor.set(0.5, 0);
LK.gui.top.addChild(roundText);
roundText.y = 100;
turnText = new Text2(getText('turn') + ' ' + getText('player') + ' 1', {
	size: 40,
	fill: 0x00AAFF
});
turnText.anchor.set(0.5, 0.5);
game.addChild(turnText);
turnText.x = 1024;
turnText.y = 600;
infoText = new Text2(getText('chooseAction'), {
	size: 36,
	fill: 0xFFFFFF
});
infoText.anchor.set(0.5, 0.5);
game.addChild(infoText);
infoText.x = 1024;
infoText.y = 700;
// Play button
playButton = game.addChild(new GameButton(getText('playTwoPlayers'), function () {
	gameMode = 'pvp';
	startGame();
}));
playButton.x = 1024;
playButton.y = 1166;
// AI Play button
playAIButton = game.addChild(new GameButton(getText('playAgainstAI'), function () {
	gameMode = 'ai';
	startGame();
}));
playAIButton.x = 1024;
playAIButton.y = 1366;
// Settings button
var settingsButton = game.addChild(new GameButton(getText('settings'), function () {
	showSettings();
}));
settingsButton.x = 1024;
settingsButton.y = 1566;
// Action buttons
var shootOpponentButton = game.addChild(new GameButton(getText('shootOpponent'), function () {
	shootOpponent();
}));
shootOpponentButton.x = 724;
shootOpponentButton.y = 1300;
shootOpponentButton.visible = false;
var shootSelfButton = game.addChild(new GameButton(getText('shootSelf'), function () {
	shootSelf();
}));
shootSelfButton.x = 1324;
shootSelfButton.y = 1300;
shootSelfButton.visible = false;
buttons.push(shootOpponentButton, shootSelfButton);
// Item buttons (will be created dynamically)
var itemButtons = [];
function setupRound() {
	gamePhase = 'setup';
	// Calculate rounds for this round
	var liveRounds = Math.min(2 + Math.floor(round / 2), 4);
	var blanks = Math.max(4 - Math.floor(round / 3), 2);
	// Load revolver
	revolver.loadChambers(liveRounds, blanks);
	// Give items to players
	giveRandomItems();
	// Update display
	var remaining = revolver.getRemainingRounds();
	infoText.setText('Ronda ' + round + ': ' + remaining.live + ' reales, ' + remaining.blank + ' de fogueo');
	roundText.setText('Ronda ' + round);
	gamePhase = 'playing';
	updateTurn();
}
function giveRandomItems() {
	// Clear existing item buttons
	for (var i = 0; i < itemButtons.length; i++) {
		itemButtons[i].destroy();
	}
	itemButtons = [];
	// Give 1-2 random items to each player
	player1.items = [];
	player2.items = [];
	for (var p = 1; p <= 2; p++) {
		var player = p === 1 ? player1 : player2;
		var numItems = 1 + Math.floor(Math.random() * 2);
		for (var i = 0; i < numItems; i++) {
			var randomItem = availableItems[Math.floor(Math.random() * availableItems.length)];
			player.items.push(randomItem);
		}
		// Create item buttons for current player
		if (p === currentPlayer) {
			createItemButtons(player);
		}
	}
}
function createItemButtons(player) {
	// Clear existing item buttons
	for (var i = 0; i < itemButtons.length; i++) {
		itemButtons[i].destroy();
	}
	itemButtons = [];
	for (var i = 0; i < player.items.length; i++) {
		var itemName = player.items[i];
		var button = game.addChild(new GameButton(itemName.replace('_', ' '), createItemCallback(i)));
		button.x = 400 + i * 250;
		button.y = 1500;
		button.scaleX = 1.0;
		button.scaleY = 1.0;
		itemButtons.push(button);
	}
}
function createItemCallback(itemIndex) {
	return function () {
		useItem(itemIndex);
	};
}
function useItem(itemIndex) {
	var player = currentPlayer === 1 ? player1 : player2;
	var itemName = player.items[itemIndex];
	switch (itemName) {
		case 'magnifying_glass':
			var nextBullet = revolver.peekNext();
			if (nextBullet === null) {
				infoText.setText('La recámara está vacía');
			} else {
				infoText.setText('La próxima bala es: ' + (nextBullet ? 'REAL' : 'DE FOGUEO'));
			}
			break;
		case 'handcuffs':
			infoText.setText('El oponente saltará su próximo turno');
			// This will be handled in switchTurn
			break;
		case 'cigarettes':
			player.heal();
			infoText.setText('Salud restaurada');
			break;
	}
	// Remove used item
	player.items.splice(itemIndex, 1);
	createItemButtons(player);
	LK.getSound('click').play();
	// Don't end turn when using items
}
function shootOpponent() {
	if (gamePhase !== 'playing') return;
	var result = revolver.fire();
	var opponent = currentPlayer === 1 ? player2 : player1;
	if (result === true) {
		// Live round - opponent takes damage
		LK.getSound('gunshot').play();
		opponent.takeDamage();
		infoText.setText('¡BANG! ¡Oponente impactado!');
		if (!opponent.isAlive) {
			endGame(currentPlayer);
			return;
		}
	} else if (result === false) {
		// Blank round
		LK.getSound('click').play();
		infoText.setText('*Clic* - Bala de fogueo');
	} else {
		// Empty chamber
		LK.getSound('click').play();
		infoText.setText('*Clic* - Recámara vacía');
	}
	// End turn
	LK.setTimeout(function () {
		switchTurn();
	}, 1500);
}
function shootSelf() {
	if (gamePhase !== 'playing') return;
	var result = revolver.fire();
	var currentPlayerObj = currentPlayer === 1 ? player1 : player2;
	if (result === true) {
		// Live round - current player takes damage
		LK.getSound('gunshot').play();
		currentPlayerObj.takeDamage();
		infoText.setText('¡BANG! ¡Te disparaste a ti mismo!');
		if (!currentPlayerObj.isAlive) {
			endGame(currentPlayer === 1 ? 2 : 1);
			return;
		}
		// End turn
		LK.setTimeout(function () {
			switchTurn();
		}, 1500);
	} else if (result === false) {
		// Blank round - continue turn
		LK.getSound('click').play();
		infoText.setText('*Clic* - ¡De fogueo! Continúa tu turno');
		// Don't switch turns
	} else {
		// Empty chamber
		LK.getSound('click').play();
		infoText.setText('*Clic* - Recámara vacía');
		// End turn
		LK.setTimeout(function () {
			switchTurn();
		}, 1500);
	}
}
function switchTurn() {
	// Check if revolver is empty
	var remaining = revolver.getRemainingRounds();
	if (remaining.live === 0 && remaining.blank === 0) {
		// Start new round
		round++;
		setupRound();
		return;
	}
	// Check for handcuffs effect
	var currentPlayerObj = currentPlayer === 1 ? player1 : player2;
	var hasHandcuffs = false;
	for (var i = 0; i < currentPlayerObj.items.length; i++) {
		if (currentPlayerObj.items[i] === 'handcuffs') {
			hasHandcuffs = true;
			currentPlayerObj.items.splice(i, 1);
			break;
		}
	}
	if (hasHandcuffs) {
		infoText.setText('Esposas usadas - el oponente salta su turno');
		// Don't switch player
		createItemButtons(currentPlayerObj);
		updateTurn();
		return;
	}
	// Normal turn switch
	currentPlayer = currentPlayer === 1 ? 2 : 1;
	updateTurn();
}
function updateTurn() {
	var currentPlayerObj = currentPlayer === 1 ? player1 : player2;
	var playerName = gameMode === 'ai' && currentPlayer === 2 ? 'IA' : 'Jugador ' + currentPlayer;
	turnText.setText('Turno del ' + playerName);
	turnText.tint = currentPlayer === 1 ? 0x00aaff : 0xff00aa;
	// Update player 2 name for AI mode
	if (gameMode === 'ai') {
		player2.nameText.setText('IA');
	} else {
		player2.nameText.setText('Jugador 2');
	}
	// Update item buttons
	createItemButtons(currentPlayerObj);
	// Show remaining rounds
	var remaining = revolver.getRemainingRounds();
	if (remaining.live === 0 && remaining.blank === 0) {
		infoText.setText('Revólver vacío - Nueva ronda comenzando...');
		LK.setTimeout(function () {
			round++;
			setupRound();
		}, 2000);
	} else {
		infoText.setText(remaining.live + ' reales, ' + remaining.blank + ' de fogueo restantes');
	}
	// AI turn logic
	if (gameMode === 'ai' && currentPlayer === 2) {
		LK.setTimeout(function () {
			makeAIMove();
		}, 1500);
	}
}
function makeAIMove() {
	if (gamePhase !== 'playing' || currentPlayer !== 2) return;
	var remaining = revolver.getRemainingRounds();
	var aiPlayer = player2;
	// AI uses items first if beneficial
	for (var i = 0; i < aiPlayer.items.length; i++) {
		var itemName = aiPlayer.items[i];
		if (itemName === 'cigarettes' && aiPlayer.health < aiPlayer.maxHealth) {
			useItem(i);
			return;
		}
		if (itemName === 'magnifying_glass') {
			useItem(i);
			return;
		}
	}
	// AI decision logic based on odds
	var totalRemaining = remaining.live + remaining.blank;
	var liveRatio = totalRemaining > 0 ? remaining.live / totalRemaining : 0;
	// If more blanks than live rounds, AI tends to shoot self
	// If more live rounds, AI shoots opponent
	if (liveRatio < 0.4) {
		infoText.setText('IA decide dispararse a sí misma...');
		LK.setTimeout(function () {
			shootSelf();
		}, 1000);
	} else {
		infoText.setText('IA decide disparar al oponente...');
		LK.setTimeout(function () {
			shootOpponent();
		}, 1000);
	}
}
function endGame(winner) {
	gamePhase = 'gameover';
	// Disable all buttons
	for (var i = 0; i < buttons.length; i++) {
		buttons[i].setEnabled(false);
	}
	for (var i = 0; i < itemButtons.length; i++) {
		itemButtons[i].setEnabled(false);
	}
	var winnerName = gameMode === 'ai' && winner === 2 ? 'IA' : 'Jugador ' + winner;
	infoText.setText('¡' + winnerName + ' Gana!');
	turnText.setText('Juego Terminado');
	LK.setScore(winner);
	LK.setTimeout(function () {
		LK.showYouWin();
	}, 2000);
}
// Hide game elements initially
player1.visible = false;
player2.visible = false;
revolver.visible = false;
turnText.visible = false;
infoText.setText(getText('welcome'));
// Settings panel variables
var settingsPanel = null;
var settingsButtons = [];
var isSettingsOpen = false;
var isMusicOn = true;
function showSettings() {
	if (isSettingsOpen) return;
	isSettingsOpen = true;
	// Create settings panel background
	settingsPanel = game.addChild(LK.getAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 4,
		scaleY: 8,
		tint: 0x222222
	}));
	settingsPanel.x = 1024;
	settingsPanel.y = 1366;
	// Settings title
	var settingsTitle = new Text2(getText('settings'), {
		size: 50,
		fill: 0xFFFFFF
	});
	settingsTitle.anchor.set(0.5, 0.5);
	settingsPanel.addChild(settingsTitle);
	settingsTitle.y = -250;
	// Language selection
	var languageLabel = new Text2(getText('language') + ':', {
		size: 40,
		fill: 0xFFFFFF
	});
	languageLabel.anchor.set(0.5, 0.5);
	settingsPanel.addChild(languageLabel);
	languageLabel.y = -150;
	// Spanish button
	var spanishButton = new GameButton(getText('spanish'), function () {
		changeLanguage('es');
		closeSettings();
		showSettings();
	});
	spanishButton.x = -150;
	spanishButton.y = -100;
	spanishButton.scaleX = 0.6;
	spanishButton.scaleY = 0.6;
	if (currentLanguage === 'es') {
		spanishButton.bg.tint = 0x00AA00;
	}
	settingsPanel.addChild(spanishButton);
	settingsButtons.push(spanishButton);
	// English button
	var englishButton = new GameButton(getText('english'), function () {
		changeLanguage('en');
		closeSettings();
		showSettings();
	});
	englishButton.x = 150;
	englishButton.y = -100;
	englishButton.scaleX = 0.6;
	englishButton.scaleY = 0.6;
	if (currentLanguage === 'en') {
		englishButton.bg.tint = 0x00AA00;
	}
	settingsPanel.addChild(englishButton);
	settingsButtons.push(englishButton);
	// Italian button
	var italianButton = new GameButton(getText('italian'), function () {
		changeLanguage('it');
		closeSettings();
		showSettings();
	});
	italianButton.x = -150;
	italianButton.y = -50;
	italianButton.scaleX = 0.6;
	italianButton.scaleY = 0.6;
	if (currentLanguage === 'it') {
		italianButton.bg.tint = 0x00AA00;
	}
	settingsPanel.addChild(italianButton);
	settingsButtons.push(italianButton);
	// Portuguese button
	var portugueseButton = new GameButton(getText('portuguese'), function () {
		changeLanguage('pt');
		closeSettings();
		showSettings();
	});
	portugueseButton.x = 150;
	portugueseButton.y = -50;
	portugueseButton.scaleX = 0.6;
	portugueseButton.scaleY = 0.6;
	if (currentLanguage === 'pt') {
		portugueseButton.bg.tint = 0x00AA00;
	}
	settingsPanel.addChild(portugueseButton);
	settingsButtons.push(portugueseButton);
	// Sound toggle button
	var soundButton = new GameButton(getText('sound') + ': ' + getText('on'), function () {
		// Toggle sound implementation would go here
	});
	soundButton.x = 0;
	soundButton.y = -10;
	settingsPanel.addChild(soundButton);
	settingsButtons.push(soundButton);
	// Music toggle button
	var musicButton = new GameButton(getText('music') + ': ' + getText(isMusicOn ? 'on' : 'off'), function () {
		isMusicOn = !isMusicOn;
		musicButton.text.setText(getText('music') + ': ' + getText(isMusicOn ? 'on' : 'off'));
		// Update music icon
		if (musicButton.musicIcon) {
			musicButton.removeChild(musicButton.musicIcon);
		}
		musicButton.musicIcon = musicButton.attachAsset(isMusicOn ? 'musicIcon' : 'musicIconOff', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -150,
			y: 0
		});
		// Toggle music
		if (isMusicOn) {
			LK.playMusic('gameMusic');
		} else {
			LK.stopMusic();
		}
	});
	musicButton.x = 0;
	musicButton.y = 90;
	// Add initial music icon
	musicButton.musicIcon = musicButton.attachAsset(isMusicOn ? 'musicIcon' : 'musicIconOff', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: -150,
		y: 0
	});
	settingsPanel.addChild(musicButton);
	settingsButtons.push(musicButton);
	// Back button to exit settings - positioned in top-right corner
	var backButton = new GameButton(getText('close'), function () {
		closeSettings();
	});
	backButton.x = 350;
	backButton.y = -250;
	backButton.scaleX = 0.7;
	backButton.scaleY = 0.7;
	settingsPanel.addChild(backButton);
	settingsButtons.push(backButton);
}
function closeSettings() {
	if (!isSettingsOpen) return;
	isSettingsOpen = false;
	if (settingsPanel) {
		settingsPanel.destroy();
		settingsPanel = null;
	}
	settingsButtons = [];
}
function startGame() {
	gamePhase = 'setup';
	// Close settings if open
	closeSettings();
	// Show game elements
	player1.visible = true;
	player2.visible = true;
	revolver.visible = true;
	turnText.visible = true;
	// Hide menu buttons
	playButton.visible = false;
	playAIButton.visible = false;
	// Show action buttons (only for human player in AI mode)
	shootOpponentButton.visible = true;
	shootSelfButton.visible = true;
	// Start the game
	setupRound();
	// Start music if enabled
	if (isMusicOn) {
		LK.playMusic('gameMusic');
	}
}

===================================================================
--- original.js
+++ change.js
@@ -855,10 +855,10 @@
 		showSettings();
 	});
 	spanishButton.x = -150;
 	spanishButton.y = -100;
-	spanishButton.scaleX = 0.8;
-	spanishButton.scaleY = 0.8;
+	spanishButton.scaleX = 0.6;
+	spanishButton.scaleY = 0.6;
 	if (currentLanguage === 'es') {
 		spanishButton.bg.tint = 0x00AA00;
 	}
 	settingsPanel.addChild(spanishButton);
@@ -870,10 +870,10 @@
 		showSettings();
 	});
 	englishButton.x = 150;
 	englishButton.y = -100;
-	englishButton.scaleX = 0.8;
-	englishButton.scaleY = 0.8;
+	englishButton.scaleX = 0.6;
+	englishButton.scaleY = 0.6;
 	if (currentLanguage === 'en') {
 		englishButton.bg.tint = 0x00AA00;
 	}
 	settingsPanel.addChild(englishButton);
@@ -885,10 +885,10 @@
 		showSettings();
 	});
 	italianButton.x = -150;
 	italianButton.y = -50;
-	italianButton.scaleX = 0.8;
-	italianButton.scaleY = 0.8;
+	italianButton.scaleX = 0.6;
+	italianButton.scaleY = 0.6;
 	if (currentLanguage === 'it') {
 		italianButton.bg.tint = 0x00AA00;
 	}
 	settingsPanel.addChild(italianButton);
@@ -900,10 +900,10 @@
 		showSettings();
 	});
 	portugueseButton.x = 150;
 	portugueseButton.y = -50;
-	portugueseButton.scaleX = 0.8;
-	portugueseButton.scaleY = 0.8;
+	portugueseButton.scaleX = 0.6;
+	portugueseButton.scaleY = 0.6;
 	if (currentLanguage === 'pt') {
 		portugueseButton.bg.tint = 0x00AA00;
 	}
 	settingsPanel.addChild(portugueseButton);