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

/**** 
* Classes
****/ 
var Card = Container.expand(function (element, damage, name, effect) {
	var self = Container.call(this);
	self.element = element;
	self.damage = damage;
	self.name = name || element;
	self.effect = effect || 'normal';
	self.isUsed = false;
	var cardBg = self.attachAsset('cardBase', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Get card-specific image based on name, fallback to element color
	var cardImageId = getCardImageId(self.name);
	var elementGraphic = self.attachAsset(cardImageId, {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -80
	});
	var elementText = new Text2(element, {
		size: 42,
		fill: 0xFFFFFF,
		font: "'Arial Black', Arial, sans-serif"
	});
	elementText.anchor.set(0.5, 0.5);
	elementText.y = -80;
	// Add dark stroke for better contrast against colored backgrounds
	elementText.stroke = 0x000000;
	elementText.strokeThickness = 2;
	self.addChild(elementText);
	var nameText = new Text2(self.name, {
		size: 32,
		fill: 0x000000,
		font: "'Arial Black', Arial, sans-serif"
	});
	nameText.anchor.set(0.5, 0.5);
	nameText.y = 20;
	// Add text stroke for better readability
	nameText.stroke = 0xFFFFFF;
	nameText.strokeThickness = 2;
	self.addChild(nameText);
	var damageText = new Text2(damage.toString(), {
		size: 64,
		fill: 0x000000,
		font: "'Arial Black', Arial, sans-serif"
	});
	damageText.anchor.set(0.5, 0.5);
	damageText.y = 60;
	// Add text stroke for better readability
	damageText.stroke = 0xFFFFFF;
	damageText.strokeThickness = 3;
	self.addChild(damageText);
	self.down = function (x, y, obj) {
		if (!self.isUsed && gameState === 'playerTurn') {
			playCard(self);
		}
	};
	return self;
});
var Enemy = Container.expand(function (name, health, difficulty) {
	var self = Container.call(this);
	self.name = name;
	self.maxHealth = health;
	self.health = health;
	self.difficulty = difficulty;
	self.isFrozen = false;
	self.hasExtraAttack = false;
	self.iceBlocked = false;
	self.deck = createEnemyDeck(difficulty);
	self.hand = [];
	var enemyGraphic = self.attachAsset('academy', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.6,
		scaleY: 0.6
	});
	var nameText = new Text2(name, {
		size: 50,
		fill: 0xFFFFFF
	});
	nameText.anchor.set(0.5, 0.5);
	nameText.y = -200;
	self.addChild(nameText);
	var healthText = new Text2('HP: ' + health, {
		size: 40,
		fill: 0xFFFFFF
	});
	healthText.anchor.set(0.5, 0.5);
	healthText.y = 200;
	self.addChild(healthText);
	self.healthText = healthText;
	self.drawHand = function () {
		// Clear existing hand visuals
		if (self.handCards) {
			for (var j = 0; j < self.handCards.length; j++) {
				if (self.handCards[j].parent) {
					self.handCards[j].parent.removeChild(self.handCards[j]);
				}
			}
		}
		self.handCards = [];
		self.hand = [];
		for (var i = 0; i < 3; i++) {
			if (self.deck.length > 0) {
				var randomIndex = Math.floor(Math.random() * self.deck.length);
				var cardData = self.deck[randomIndex];
				self.hand.push(cardData);
				// Create visual card for enemy
				var enemyCard = new Card(cardData.element, cardData.damage);
				enemyCard.x = -400 + i * 200;
				enemyCard.y = -400;
				enemyCard.scaleX = 0.6;
				enemyCard.scaleY = 0.6;
				self.addChild(enemyCard);
				self.handCards.push(enemyCard);
			}
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health < 0) self.health = 0;
		self.healthText.setText('HP: ' + self.health);
		tween(self, {
			tint: 0xff0000
		}, {
			duration: 200,
			onFinish: function onFinish() {
				tween(self, {
					tint: 0xffffff
				}, {
					duration: 200
				});
			}
		});
	};
	self.removeCardFromHand = function (cardIndex) {
		if (cardIndex >= 0 && cardIndex < self.hand.length) {
			// Remove from hand array
			self.hand.splice(cardIndex, 1);
			// Remove visual card
			if (self.handCards && self.handCards[cardIndex]) {
				self.removeChild(self.handCards[cardIndex]);
				self.handCards.splice(cardIndex, 1);
			}
		}
	};
	self.playTurn = function () {
		if (self.isFrozen) {
			self.isFrozen = false;
			endEnemyTurn();
			return;
		}
		if (self.hand.length > 0) {
			var cardIndex = Math.floor(Math.random() * self.hand.length);
			var card = self.hand[cardIndex];
			// If ice is blocked, find a non-ice card
			if (self.iceBlocked && card.element === 'Ice') {
				var nonIceCards = [];
				for (var i = 0; i < self.hand.length; i++) {
					if (self.hand[i].element !== 'Ice') {
						nonIceCards.push({
							card: self.hand[i],
							index: i
						});
					}
				}
				if (nonIceCards.length > 0) {
					var randomNonIce = nonIceCards[Math.floor(Math.random() * nonIceCards.length)];
					card = randomNonIce.card;
					cardIndex = randomNonIce.index;
				}
			}
			// Reset ice block after turn
			self.iceBlocked = false;
			enemyPlayCard(card, cardIndex);
			// Check for extra attack from hombre de nieve effect
			if (self.hasExtraAttack && self.hand.length > 0) {
				self.hasExtraAttack = false;
				// Play another card with damage 1
				LK.setTimeout(function () {
					if (self.hand.length > 0) {
						var extraCardIndex = Math.floor(Math.random() * self.hand.length);
						var extraCard = {
							element: 'Ice',
							damage: 1
						};
						enemyPlayCard(extraCard, extraCardIndex);
					}
				}, 500);
			}
		} else {
			endEnemyTurn();
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Ice card images
// Rock card images
// Plant card images
// Air card images
// Water card images
// Fire card images
// Game state variables
var gameState = 'menu'; // 'menu', 'modeSelect', 'battle', 'victory', 'defeat'
var gameMode = 'adventure'; // 'adventure', 'roguelike'
var roguelikeLevel = storage.highestLevel || 0;
// Helper function to get card image ID from card name
function getCardImageId(cardName) {
	var nameMap = {
		// Fire cards
		'Llamarada': 'llamarada',
		'Fénix': 'fenix',
		'Brasas': 'brasas',
		'Llama': 'llama',
		'Mechero': 'mechero',
		// Water cards
		'Gota de agua': 'gota_de_agua',
		'Luna roja': 'luna_roja',
		'Agua oxigenada': 'agua_oxigenada',
		'Marea': 'marea',
		'Pirata': 'pirata',
		// Air cards
		'Vendaval': 'vendaval',
		'Brisa': 'brisa',
		'Huracán': 'huracan',
		// Plant cards
		'Arboleda': 'arboleda',
		'Serafín': 'serafin',
		'Rama': 'rama',
		'Vida extra': 'vida_extra',
		'Aullidos del bosque': 'aullidos_del_bosque',
		// Rock cards
		'Pedrada': 'pedrada',
		'Tormenta de arena': 'tormenta_de_arena',
		'Sarcófago': 'sarcofago',
		'Terremoto': 'terremoto',
		// Ice cards
		'Nevada': 'nevada',
		'Ventisca': 'ventisca',
		'Bola de nieve': 'bola_de_nieve',
		'Hombre de nieve': 'hombre_de_nieve'
	};
	// Return mapped image ID or fallback to generic element card
	return nameMap[cardName] || getElementCardId(cardName);
}
// Helper function to get fallback element card ID
function getElementCardId(element) {
	switch (element) {
		case 'Fire':
			return 'fireCard';
		case 'Water':
			return 'waterCard';
		case 'Air':
			return 'airCard';
		case 'Plant':
			return 'plantCard';
		case 'Rock':
			return 'rockCard';
		case 'Ice':
			return 'iceCard';
		default:
			return 'cardBase';
	}
}
// Helper function to play element-specific sounds
function playElementSound(element) {
	var soundNumber = Math.floor(Math.random() * 5) + 1;
	var soundId = element.toLowerCase() + soundNumber;
	LK.getSound(soundId).play();
}
var currentBattle = 0;
var playerHealth = 10;
var playerMaxHealth = 10;
var playerDeck = [];
var playerHand = [];
var currentEnemy = null;
var enemies = [];
var turnCounter = 0;
// UI elements
var menuContainer = new Container();
var battleContainer = new Container();
var playerHealthBar = null;
var playerHealthText = null;
var turnText = null;
var battleText = null;
// Initialize player deck
function initializeDeck() {
	var elements = ['Fire', 'Water', 'Air', 'Plant', 'Rock', 'Ice'];
	playerDeck = [];
	for (var i = 0; i < elements.length; i++) {
		if (elements[i] === 'Fire') {
			// Add specific fire cards with names and effects
			var fireCards = [{
				element: 'Fire',
				damage: 3,
				name: 'Llamarada',
				effect: 'chooseBurn'
			}, {
				element: 'Fire',
				damage: 2,
				name: 'Fénix',
				effect: 'heal'
			}, {
				element: 'Fire',
				damage: 2,
				name: 'Brasas',
				effect: 'normal'
			}, {
				element: 'Fire',
				damage: 2,
				name: 'Llama',
				effect: 'normal'
			}, {
				element: 'Fire',
				damage: 1,
				name: 'Mechero',
				effect: 'preventIce'
			}];
			for (var k = 0; k < fireCards.length; k++) {
				playerDeck.push(fireCards[k]);
			}
		} else if (elements[i] === 'Air') {
			// Add specific air cards with names and effects
			var airCards = [{
				element: 'Air',
				damage: 2,
				name: 'Vendaval',
				effect: 'normal'
			}, {
				element: 'Air',
				damage: 1,
				name: 'Brisa',
				effect: 'normal'
			}, {
				element: 'Air',
				damage: 2,
				name: 'Huracán',
				effect: 'replaceCards'
			}];
			for (var k = 0; k < airCards.length; k++) {
				playerDeck.push(airCards[k]);
			}
			// Add two more air cards to make 5 total
			playerDeck.push({
				element: 'Air',
				damage: 1,
				name: 'Vendaval',
				effect: 'normal'
			});
			playerDeck.push({
				element: 'Air',
				damage: 1,
				name: 'Brisa',
				effect: 'normal'
			});
		} else if (elements[i] === 'Water') {
			// Add specific water cards with names and effects
			var waterCards = [{
				element: 'Water',
				damage: 1,
				name: 'Gota de agua',
				effect: 'normal'
			}, {
				element: 'Water',
				damage: 2,
				name: 'Luna roja',
				effect: 'normal'
			}, {
				element: 'Water',
				damage: 0,
				name: 'Agua oxigenada',
				effect: 'heal'
			}, {
				element: 'Water',
				damage: 2,
				name: 'Marea',
				effect: 'normal'
			}, {
				element: 'Water',
				damage: 1,
				name: 'Pirata',
				effect: 'steal'
			}];
			for (var k = 0; k < waterCards.length; k++) {
				playerDeck.push(waterCards[k]);
			}
		} else if (elements[i] === 'Rock') {
			// Add specific rock/earth cards with names and effects
			var rockCards = [{
				element: 'Rock',
				damage: 2,
				name: 'Pedrada',
				effect: 'normal'
			}, {
				element: 'Rock',
				damage: 2,
				name: 'Tormenta de arena',
				effect: 'normal'
			}, {
				element: 'Rock',
				damage: 2,
				name: 'Sarcófago',
				effect: 'damageAndHeal'
			}, {
				element: 'Rock',
				damage: 2,
				name: 'Terremoto',
				effect: 'replaceAllCards'
			}];
			for (var k = 0; k < rockCards.length; k++) {
				playerDeck.push(rockCards[k]);
			}
			// Add one more rock card to make 5 total
			playerDeck.push({
				element: 'Rock',
				damage: 2,
				name: 'Pedrada',
				effect: 'normal'
			});
		} else if (elements[i] === 'Plant') {
			// Add specific plant cards with names and effects
			var plantCards = [{
				element: 'Plant',
				damage: 2,
				name: 'Arboleda',
				effect: 'normal'
			}, {
				element: 'Plant',
				damage: 0,
				name: 'Serafín',
				effect: 'heal'
			}, {
				element: 'Plant',
				damage: 1,
				name: 'Rama',
				effect: 'normal'
			}, {
				element: 'Plant',
				damage: 0,
				name: 'Vida extra',
				effect: 'increaseMaxHealth'
			}, {
				element: 'Plant',
				damage: 2,
				name: 'Aullidos del bosque',
				effect: 'skipEnemyTurn'
			}];
			for (var k = 0; k < plantCards.length; k++) {
				playerDeck.push(plantCards[k]);
			}
		} else if (elements[i] === 'Ice') {
			// Add specific ice cards with names and effects
			var iceCards = [{
				element: 'Ice',
				damage: 2,
				name: 'Nevada',
				effect: 'normal'
			}, {
				element: 'Ice',
				damage: 2,
				name: 'Ventisca',
				effect: 'blizzard'
			}, {
				element: 'Ice',
				damage: 1,
				name: 'Bola de nieve',
				effect: 'normal'
			}, {
				element: 'Ice',
				damage: 2,
				name: 'Hombre de nieve',
				effect: 'snowmanAttack'
			}];
			for (var k = 0; k < iceCards.length; k++) {
				playerDeck.push(iceCards[k]);
			}
			// Add one more ice card to make 5 total
			playerDeck.push({
				element: 'Ice',
				damage: 1,
				name: 'Bola de nieve',
				effect: 'normal'
			});
		} else {
			for (var j = 0; j < 5; j++) {
				var damage = 1;
				playerDeck.push({
					element: elements[i],
					damage: damage
				});
			}
		}
	}
}
function createEnemyDeck(difficulty) {
	var deck = [];
	var elements = ['Fire', 'Water', 'Air', 'Plant', 'Rock', 'Ice'];
	var cardCount = 15 + difficulty * 5;
	for (var i = 0; i < cardCount; i++) {
		var element = elements[Math.floor(Math.random() * elements.length)];
		var damage = 1 + Math.floor(Math.random() * (difficulty + 1));
		deck.push({
			element: element,
			damage: damage
		});
	}
	return deck;
}
function initializeEnemies() {
	enemies = [new Enemy('Tutorial Apprentice', 5, 0), new Enemy('Novice Mage', 8, 1), new Enemy('Advanced Scholar', 12, 2), new Enemy('Master Wizard', 15, 3)];
}
function createMenu() {
	menuContainer.removeChildren();
	var bg = LK.getAsset('background', {
		anchorX: 0,
		anchorY: 0
	});
	menuContainer.addChild(bg);
	// Magical school background
	var magicSchool = LK.getAsset('magicSchool', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 900
	});
	menuContainer.addChild(magicSchool);
	// Add magical towers and buildings
	var leftTower = LK.getAsset('academy', {
		anchorX: 0.5,
		anchorY: 1,
		x: 400,
		y: 1200,
		scaleX: 0.8,
		scaleY: 1.2
	});
	menuContainer.addChild(leftTower);
	var rightTower = LK.getAsset('academy', {
		anchorX: 0.5,
		anchorY: 1,
		x: 1648,
		y: 1200,
		scaleX: 0.8,
		scaleY: 1.2
	});
	menuContainer.addChild(rightTower);
	var mainBuilding = LK.getAsset('academy', {
		anchorX: 0.5,
		anchorY: 1,
		x: 1024,
		y: 1300,
		scaleX: 1.5,
		scaleY: 1.0
	});
	menuContainer.addChild(mainBuilding);
	var titleText = new Text2('Elemental Mage Academy', {
		size: 80,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.x = 1024;
	titleText.y = 400;
	menuContainer.addChild(titleText);
	var adventureButton = LK.getAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 1500
	});
	menuContainer.addChild(adventureButton);
	var adventureText = new Text2('Adventure Mode', {
		size: 50,
		fill: 0xFFFFFF
	});
	adventureText.anchor.set(0.5, 0.5);
	adventureText.x = 1024;
	adventureText.y = 1500;
	menuContainer.addChild(adventureText);
	adventureButton.down = function () {
		gameMode = 'adventure';
		startBattle();
	};
	var roguelikeButton = LK.getAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 1700
	});
	menuContainer.addChild(roguelikeButton);
	var roguelikeText = new Text2('Roguelike Mode', {
		size: 50,
		fill: 0xFFFFFF
	});
	roguelikeText.anchor.set(0.5, 0.5);
	roguelikeText.x = 1024;
	roguelikeText.y = 1700;
	menuContainer.addChild(roguelikeText);
	roguelikeButton.down = function () {
		gameMode = 'roguelike';
		startBattle();
	};
	// Fire Book Button
	var fireBookButton = LK.getAsset('fireCard', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 200,
		y: 2000
	});
	menuContainer.addChild(fireBookButton);
	var fireBookText = new Text2('Fire\nBook', {
		size: 40,
		fill: 0xFFFFFF,
		font: "'Arial Black', Arial, sans-serif",
		stroke: 0x000000,
		strokeThickness: 3
	});
	fireBookText.anchor.set(0.5, 0.5);
	fireBookText.x = 200;
	fireBookText.y = 2000;
	menuContainer.addChild(fireBookText);
	fireBookButton.down = function () {
		showElementBook('Fire');
	};
	// Water Book Button
	var waterBookButton = LK.getAsset('waterCard', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 400,
		y: 2000
	});
	menuContainer.addChild(waterBookButton);
	var waterBookText = new Text2('Water\nBook', {
		size: 40,
		fill: 0xFFFFFF,
		font: "'Arial Black', Arial, sans-serif",
		stroke: 0x000000,
		strokeThickness: 3
	});
	waterBookText.anchor.set(0.5, 0.5);
	waterBookText.x = 400;
	waterBookText.y = 2000;
	menuContainer.addChild(waterBookText);
	waterBookButton.down = function () {
		showElementBook('Water');
	};
	// Air Book Button
	var airBookButton = LK.getAsset('airCard', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 600,
		y: 2000
	});
	menuContainer.addChild(airBookButton);
	var airBookText = new Text2('Air\nBook', {
		size: 40,
		fill: 0xFFFFFF,
		font: "'Arial Black', Arial, sans-serif",
		stroke: 0x000000,
		strokeThickness: 3
	});
	airBookText.anchor.set(0.5, 0.5);
	airBookText.x = 600;
	airBookText.y = 2000;
	menuContainer.addChild(airBookText);
	airBookButton.down = function () {
		showElementBook('Air');
	};
	// Plant Book Button
	var plantBookButton = LK.getAsset('plantCard', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 800,
		y: 2000
	});
	menuContainer.addChild(plantBookButton);
	var plantBookText = new Text2('Plant\nBook', {
		size: 40,
		fill: 0xFFFFFF,
		font: "'Arial Black', Arial, sans-serif",
		stroke: 0x000000,
		strokeThickness: 3
	});
	plantBookText.anchor.set(0.5, 0.5);
	plantBookText.x = 800;
	plantBookText.y = 2000;
	menuContainer.addChild(plantBookText);
	plantBookButton.down = function () {
		showElementBook('Plant');
	};
	// Rock Book Button
	var rockBookButton = LK.getAsset('rockCard', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1000,
		y: 2000
	});
	menuContainer.addChild(rockBookButton);
	var rockBookText = new Text2('Rock\nBook', {
		size: 40,
		fill: 0xFFFFFF,
		font: "'Arial Black', Arial, sans-serif",
		stroke: 0x000000,
		strokeThickness: 3
	});
	rockBookText.anchor.set(0.5, 0.5);
	rockBookText.x = 1000;
	rockBookText.y = 2000;
	menuContainer.addChild(rockBookText);
	rockBookButton.down = function () {
		showElementBook('Rock');
	};
	// Ice Book Button
	var iceBookButton = LK.getAsset('iceCard', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1200,
		y: 2000
	});
	menuContainer.addChild(iceBookButton);
	var iceBookText = new Text2('Ice\nBook', {
		size: 40,
		fill: 0xFFFFFF,
		font: "'Arial Black', Arial, sans-serif",
		stroke: 0x000000,
		strokeThickness: 3
	});
	iceBookText.anchor.set(0.5, 0.5);
	iceBookText.x = 1200;
	iceBookText.y = 2000;
	menuContainer.addChild(iceBookText);
	iceBookButton.down = function () {
		showElementBook('Ice');
	};
	if (roguelikeLevel > 0) {
		var recordText = new Text2('Roguelike Record: Level ' + roguelikeLevel, {
			size: 40,
			fill: 0xFFD700
		});
		recordText.anchor.set(0.5, 0.5);
		recordText.x = 1024;
		recordText.y = 1850;
		menuContainer.addChild(recordText);
	}
	game.addChild(menuContainer);
}
function createBattle() {
	battleContainer.removeChildren();
	// Background
	var bg = LK.getAsset('background', {
		anchorX: 0,
		anchorY: 0
	});
	battleContainer.addChild(bg);
	// Player health
	playerHealthBar = LK.getAsset('healthBar', {
		anchorX: 0,
		anchorY: 0,
		x: 100,
		y: 100
	});
	battleContainer.addChild(playerHealthBar);
	playerHealthText = new Text2('HP: ' + playerHealth + '/' + playerMaxHealth, {
		size: 30,
		fill: 0xFFFFFF
	});
	playerHealthText.anchor.set(0, 0.5);
	playerHealthText.x = 420;
	playerHealthText.y = 120;
	battleContainer.addChild(playerHealthText);
	// Turn indicator
	turnText = new Text2('Your Turn - Turn 1', {
		size: 40,
		fill: 0xFFFFFF
	});
	turnText.anchor.set(0.5, 0.5);
	turnText.x = 1024;
	turnText.y = 200;
	battleContainer.addChild(turnText);
	// Battle text
	battleText = new Text2('Battle ' + (currentBattle + 1), {
		size: 60,
		fill: 0xFFFFFF
	});
	battleText.anchor.set(0.5, 0.5);
	battleText.x = 1024;
	battleText.y = 300;
	battleContainer.addChild(battleText);
	// Enemy
	currentEnemy = enemies[currentBattle];
	currentEnemy.x = 1024;
	currentEnemy.y = 800;
	battleContainer.addChild(currentEnemy);
	// Add deck pile (face down)
	var deckPile = LK.getAsset('deckPile', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1750,
		y: 2200
	});
	battleContainer.addChild(deckPile);
	var deckText = new Text2('Deck', {
		size: 30,
		fill: 0xFFFFFF
	});
	deckText.anchor.set(0.5, 0.5);
	deckText.x = 1750;
	deckText.y = 2350;
	battleContainer.addChild(deckText);
	game.addChild(battleContainer);
	drawPlayerHand();
	currentEnemy.drawHand();
}
function drawPlayerHand() {
	// Remove existing hand
	for (var i = battleContainer.children.length - 1; i >= 0; i--) {
		var child = battleContainer.children[i];
		if (child instanceof Card) {
			battleContainer.removeChild(child);
		}
	}
	playerHand = [];
	for (var i = 0; i < 3; i++) {
		if (playerDeck.length > 0) {
			var randomIndex = Math.floor(Math.random() * playerDeck.length);
			var cardData = playerDeck[randomIndex];
			var card = new Card(cardData.element, cardData.damage, cardData.name, cardData.effect);
			card.x = 400 + i * 350;
			card.y = 2200;
			playerHand.push(card);
			battleContainer.addChild(card);
		}
	}
}
function playCard(card) {
	if (gameState !== 'playerTurn') return;
	card.isUsed = true;
	LK.getSound('cardPlay').play();
	playElementSound(card.element);
	// Apply card effects
	var damage = card.damage;
	var element = card.element;
	switch (element) {
		case 'Fire':
			// Handle special fire card effects
			if (card.effect === 'chooseBurn') {
				// Llamarada - deal 3 damage and let player choose card to burn
				if (currentEnemy.hand.length > 0) {
					var burnIndex = Math.floor(Math.random() * currentEnemy.hand.length);
					currentEnemy.removeCardFromHand(burnIndex);
				}
			} else if (card.effect === 'heal') {
				// Fénix - deal 2 damage and heal 2 HP
				playerHealth = Math.min(playerHealth + 2, playerMaxHealth);
				updatePlayerHealth();
			} else if (card.effect === 'preventIce') {
				// Mechero - deal 1 damage and prevent enemy from using ice cards next turn
				currentEnemy.iceBlocked = true;
			} else {
				// Brasas and Llama - deal 2 damage normally
				if (currentEnemy.hand.length > 0) {
					var burnIndex = Math.floor(Math.random() * currentEnemy.hand.length);
					currentEnemy.removeCardFromHand(burnIndex);
				}
			}
			break;
		case 'Water':
			// Handle special water card effects
			if (card.effect === 'heal') {
				// Agua oxigenada - heal 3 HP (no damage)
				playerHealth = Math.min(playerHealth + 3, playerMaxHealth);
				updatePlayerHealth();
				damage = 0; // No damage dealt
			} else if (card.effect === 'steal') {
				// Pirata - deal 1 damage and steal a card from enemy
				if (currentEnemy.hand.length > 0 && playerHand.length < 3) {
					var stealIndex = Math.floor(Math.random() * currentEnemy.hand.length);
					var stolenCardData = currentEnemy.hand[stealIndex];
					currentEnemy.removeCardFromHand(stealIndex);
					// Add stolen card to player hand
					var stolenCard = new Card(stolenCardData.element, stolenCardData.damage, stolenCardData.name || stolenCardData.element, stolenCardData.effect || 'normal');
					stolenCard.x = 400 + playerHand.length * 350;
					stolenCard.y = 2200;
					playerHand.push(stolenCard);
					battleContainer.addChild(stolenCard);
				}
			}
			break;
		case 'Plant':
			// Handle special plant card effects
			if (card.effect === 'heal') {
				// Serafín - heal 2 HP (no damage)
				playerHealth = Math.min(playerHealth + 2, playerMaxHealth);
				updatePlayerHealth();
				damage = 0; // No damage dealt
			} else if (card.effect === 'increaseMaxHealth') {
				// Vida extra - increase max health by 1
				playerMaxHealth += 1;
				updatePlayerHealth();
				damage = 0; // No damage dealt
			} else if (card.effect === 'skipEnemyTurn') {
				// Aullidos del bosque - deal 2 damage and enemy loses turn
				currentEnemy.isFrozen = true;
			}
			// Standard damage for arboleda and rama
			break;
		case 'Air':
			// Handle special air card effects
			if (card.effect === 'replaceCards') {
				// Huracán - deal 2 damage and replace enemy's 3 cards with random ones from their deck
				currentEnemy.drawHand();
			} else {
				// Vendaval and Brisa - standard damage without replacing cards
			}
			break;
		case 'Rock':
			// Handle special rock card effects
			if (card.effect === 'damageAndHeal') {
				// Sarcófago - deal 2 damage and heal 2 HP
				playerHealth = Math.min(playerHealth + 2, playerMaxHealth);
				updatePlayerHealth();
			} else if (card.effect === 'replaceAllCards') {
				// Terremoto - deal 2 damage to enemy and both players get new cards
				currentEnemy.drawHand();
				drawPlayerHand();
			}
			// Standard damage for all rock cards
			break;
		case 'Ice':
			// Handle special ice card effects
			if (card.effect === 'blizzard') {
				// Ventisca - deal 2 damage and 10% chance enemy can't attack next turn
				if (Math.random() < 0.1) {
					currentEnemy.isFrozen = true;
				}
			} else if (card.effect === 'snowmanAttack') {
				// Hombre de nieve - deal 2 damage and can attack again next turn
				// Set flag for extra attack (handled in enemy turn logic)
				currentEnemy.hasExtraAttack = true;
			} else {
				// Nevada and Bola de nieve - freeze enemy for next turn + damage
				currentEnemy.isFrozen = true;
			}
			break;
	}
	currentEnemy.takeDamage(damage);
	LK.getSound('damage').play();
	// Remove card from hand
	var cardIndex = playerHand.indexOf(card);
	if (cardIndex !== -1) {
		playerHand.splice(cardIndex, 1);
	}
	battleContainer.removeChild(card);
	// Check if enemy is defeated (must reach exactly 0 health)
	if (currentEnemy.health === 0) {
		LK.getSound('victory').play();
		currentBattle++;
		// Handle victory based on game mode
		if (gameMode === 'roguelike') {
			// Add 1 health for winning a battle
			playerHealth = Math.min(playerHealth + 1, 10);
			// Update roguelike progress
			if (currentBattle > roguelikeLevel) {
				roguelikeLevel = currentBattle;
				storage.highestLevel = roguelikeLevel;
			}
		} else {
			// Adventure mode - restore full health
			playerHealth = 10;
		}
		// Update player health display after victory
		updatePlayerHealth();
		if (currentBattle >= enemies.length) {
			// All battles won
			LK.showYouWin();
		} else {
			// Next battle
			LK.setTimeout(function () {
				createBattle();
				gameState = 'playerTurn';
				turnText.setText('Your Turn - Turn 1');
			}, 2000);
		}
		return;
	}
	endPlayerTurn();
}
function endPlayerTurn() {
	gameState = 'enemyTurn';
	turnText.setText('Enemy Turn - Turn ' + turnCounter);
	LK.setTimeout(function () {
		currentEnemy.playTurn();
	}, 1000);
}
function enemyPlayCard(cardData, cardIndex) {
	playElementSound(cardData.element);
	var damage = cardData.damage;
	var element = cardData.element;
	// Remove the played card from enemy hand
	currentEnemy.removeCardFromHand(cardIndex);
	switch (element) {
		case 'Fire':
			// Fire burns one random player card + damage
			if (playerHand.length > 0) {
				var burnIndex = Math.floor(Math.random() * playerHand.length);
				var cardToBurn = playerHand[burnIndex];
				playerHand.splice(burnIndex, 1);
				battleContainer.removeChild(cardToBurn);
			}
			damage += 2;
			break;
		case 'Air':
			drawPlayerHand();
			break;
		case 'Ice':
			// Player frozen (skip next turn - handled in game flow)
			break;
	}
	playerHealth -= damage;
	if (playerHealth < 0) playerHealth = 0;
	updatePlayerHealth();
	LK.getSound('damage').play();
	if (playerHealth === 0) {
		// In roguelike mode, track the level where player died
		if (gameMode === 'roguelike' && currentBattle > roguelikeLevel) {
			roguelikeLevel = currentBattle;
			storage.highestLevel = roguelikeLevel;
		}
		LK.showGameOver();
		return;
	}
	endEnemyTurn();
}
function endEnemyTurn() {
	// Complete turn cycle - both player and enemy have played
	turnCounter++;
	gameState = 'playerTurn';
	turnText.setText('Your Turn - Turn ' + turnCounter);
	// Both players draw new hands after a complete turn
	drawPlayerHand();
	currentEnemy.drawHand();
}
function updatePlayerHealth() {
	var healthPercentage = playerHealth / playerMaxHealth;
	playerHealthBar.scaleX = healthPercentage;
	playerHealthText.setText('HP: ' + playerHealth + '/' + playerMaxHealth);
}
function startBattle() {
	gameState = 'battle';
	currentBattle = 0;
	turnCounter = 0;
	if (gameMode === 'adventure') {
		playerHealth = 10;
	} else {
		// Roguelike mode - start with base health
		playerHealth = 10;
	}
	game.removeChild(menuContainer);
	createBattle();
	gameState = 'playerTurn';
}
function showElementBook(element) {
	// Create book container
	var bookContainer = new Container();
	// Background
	var bookBg = LK.getAsset('background', {
		anchorX: 0,
		anchorY: 0
	});
	bookContainer.addChild(bookBg);
	// Title
	var titleText = new Text2(element + ' Element Cards', {
		size: 60,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.x = 1024;
	titleText.y = 300;
	bookContainer.addChild(titleText);
	// Get element cards based on element type
	var elementCards = [];
	switch (element) {
		case 'Fire':
			elementCards = [{
				name: 'Llamarada',
				damage: 3,
				effect: 'Deal 3 damage and burn enemy card'
			}, {
				name: 'Fénix',
				damage: 2,
				effect: 'Deal 2 damage and heal 2 HP'
			}, {
				name: 'Brasas',
				damage: 2,
				effect: 'Deal 2 damage and burn enemy card'
			}, {
				name: 'Llama',
				damage: 2,
				effect: 'Deal 2 damage and burn enemy card'
			}, {
				name: 'Mechero',
				damage: 1,
				effect: 'Deal 1 damage and prevent enemy from using ice cards next turn'
			}];
			break;
		case 'Water':
			elementCards = [{
				name: 'Gota de agua',
				damage: 1,
				effect: 'Deal 1 damage'
			}, {
				name: 'Luna roja',
				damage: 2,
				effect: 'Deal 2 damage'
			}, {
				name: 'Agua oxigenada',
				damage: 0,
				effect: 'Heal 3 HP'
			}, {
				name: 'Marea',
				damage: 2,
				effect: 'Deal 2 damage'
			}, {
				name: 'Pirata',
				damage: 1,
				effect: 'Deal 1 damage and steal enemy card'
			}];
			break;
		case 'Air':
			elementCards = [{
				name: 'Vendaval',
				damage: 2,
				effect: 'Deal 2 damage'
			}, {
				name: 'Brisa',
				damage: 1,
				effect: 'Deal 1 damage'
			}, {
				name: 'Huracán',
				damage: 2,
				effect: 'Deal 2 damage and replace enemy cards'
			}];
			break;
		case 'Plant':
			elementCards = [{
				name: 'Arboleda',
				damage: 2,
				effect: 'Deal 2 damage'
			}, {
				name: 'Serafín',
				damage: 0,
				effect: 'Heal 2 HP'
			}, {
				name: 'Rama',
				damage: 1,
				effect: 'Deal 1 damage'
			}, {
				name: 'Vida extra',
				damage: 0,
				effect: 'Increase max health by 1'
			}, {
				name: 'Aullidos del bosque',
				damage: 2,
				effect: 'Deal 2 damage, enemy loses turn'
			}];
			break;
		case 'Rock':
			elementCards = [{
				name: 'Pedrada',
				damage: 2,
				effect: 'Deal 2 damage'
			}, {
				name: 'Tormenta de arena',
				damage: 2,
				effect: 'Deal 2 damage'
			}, {
				name: 'Sarcófago',
				damage: 2,
				effect: 'Deal 2 damage and heal 2 HP'
			}, {
				name: 'Terremoto',
				damage: 2,
				effect: 'Deal 2 damage, both players get new cards'
			}];
			break;
		case 'Ice':
			elementCards = [{
				name: 'Nevada',
				damage: 2,
				effect: 'Deal 2 damage and freeze enemy'
			}, {
				name: 'Ventisca',
				damage: 2,
				effect: 'Deal 2 damage, 10% chance enemy cannot attack'
			}, {
				name: 'Bola de nieve',
				damage: 1,
				effect: 'Deal 1 damage and freeze enemy'
			}, {
				name: 'Hombre de nieve',
				damage: 2,
				effect: 'Deal 2 damage, can attack again for 1 damage next turn'
			}];
			break;
	}
	// Display cards
	for (var i = 0; i < elementCards.length; i++) {
		var cardInfo = elementCards[i];
		var yPos = 500 + i * 250;
		// Card name
		var nameText = new Text2(cardInfo.name, {
			size: 40,
			fill: 0xFFD700
		});
		nameText.anchor.set(0, 0.5);
		nameText.x = 200;
		nameText.y = yPos;
		bookContainer.addChild(nameText);
		// Damage
		var damageText = new Text2('Damage: ' + cardInfo.damage, {
			size: 30,
			fill: 0xFFFFFF
		});
		damageText.anchor.set(0, 0.5);
		damageText.x = 200;
		damageText.y = yPos + 40;
		bookContainer.addChild(damageText);
		// Effect
		var effectText = new Text2('Effect: ' + cardInfo.effect, {
			size: 25,
			fill: 0xCCCCCC
		});
		effectText.anchor.set(0, 0.5);
		effectText.x = 200;
		effectText.y = yPos + 80;
		bookContainer.addChild(effectText);
	}
	// Back button
	var backButton = LK.getAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 2400
	});
	bookContainer.addChild(backButton);
	var backText = new Text2('Back to Menu', {
		size: 40,
		fill: 0xFFFFFF
	});
	backText.anchor.set(0.5, 0.5);
	backText.x = 1024;
	backText.y = 2400;
	bookContainer.addChild(backText);
	backButton.down = function () {
		game.removeChild(bookContainer);
	};
	game.addChild(bookContainer);
}
// Initialize game
initializeDeck();
initializeEnemies();
createMenu();
game.update = function () {
	// Game loop handled by turn-based system
};

===================================================================
--- original.js
+++ change.js
@@ -19,30 +19,11 @@
 	var cardBg = self.attachAsset('cardBase', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
-	var elementColor = '';
-	switch (element) {
-		case 'Fire':
-			elementColor = 'fireCard';
-			break;
-		case 'Water':
-			elementColor = 'waterCard';
-			break;
-		case 'Air':
-			elementColor = 'airCard';
-			break;
-		case 'Plant':
-			elementColor = 'plantCard';
-			break;
-		case 'Rock':
-			elementColor = 'rockCard';
-			break;
-		case 'Ice':
-			elementColor = 'iceCard';
-			break;
-	}
-	var elementGraphic = self.attachAsset(elementColor, {
+	// Get card-specific image based on name, fallback to element color
+	var cardImageId = getCardImageId(self.name);
+	var elementGraphic = self.attachAsset(cardImageId, {
 		anchorX: 0.5,
 		anchorY: 0.5,
 		y: -80
 	});
@@ -233,12 +214,76 @@
 
 /**** 
 * Game Code
 ****/ 
+// Ice card images
+// Rock card images
+// Plant card images
+// Air card images
+// Water card images
+// Fire card images
 // Game state variables
 var gameState = 'menu'; // 'menu', 'modeSelect', 'battle', 'victory', 'defeat'
 var gameMode = 'adventure'; // 'adventure', 'roguelike'
 var roguelikeLevel = storage.highestLevel || 0;
+// Helper function to get card image ID from card name
+function getCardImageId(cardName) {
+	var nameMap = {
+		// Fire cards
+		'Llamarada': 'llamarada',
+		'Fénix': 'fenix',
+		'Brasas': 'brasas',
+		'Llama': 'llama',
+		'Mechero': 'mechero',
+		// Water cards
+		'Gota de agua': 'gota_de_agua',
+		'Luna roja': 'luna_roja',
+		'Agua oxigenada': 'agua_oxigenada',
+		'Marea': 'marea',
+		'Pirata': 'pirata',
+		// Air cards
+		'Vendaval': 'vendaval',
+		'Brisa': 'brisa',
+		'Huracán': 'huracan',
+		// Plant cards
+		'Arboleda': 'arboleda',
+		'Serafín': 'serafin',
+		'Rama': 'rama',
+		'Vida extra': 'vida_extra',
+		'Aullidos del bosque': 'aullidos_del_bosque',
+		// Rock cards
+		'Pedrada': 'pedrada',
+		'Tormenta de arena': 'tormenta_de_arena',
+		'Sarcófago': 'sarcofago',
+		'Terremoto': 'terremoto',
+		// Ice cards
+		'Nevada': 'nevada',
+		'Ventisca': 'ventisca',
+		'Bola de nieve': 'bola_de_nieve',
+		'Hombre de nieve': 'hombre_de_nieve'
+	};
+	// Return mapped image ID or fallback to generic element card
+	return nameMap[cardName] || getElementCardId(cardName);
+}
+// Helper function to get fallback element card ID
+function getElementCardId(element) {
+	switch (element) {
+		case 'Fire':
+			return 'fireCard';
+		case 'Water':
+			return 'waterCard';
+		case 'Air':
+			return 'airCard';
+		case 'Plant':
+			return 'plantCard';
+		case 'Rock':
+			return 'rockCard';
+		case 'Ice':
+			return 'iceCard';
+		default:
+			return 'cardBase';
+	}
+}
 // Helper function to play element-specific sounds
 function playElementSound(element) {
 	var soundNumber = Math.floor(Math.random() * 5) + 1;
 	var soundId = element.toLowerCase() + soundNumber;