/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	trophies: 0,
	purpleCoins: 1000,
	blueGems: 50,
	currentArena: 0,
	ownedCards: {},
	deck: [],
	elixir: 5
});

/**** 
* Classes
****/ 
var Card = Container.expand(function () {
	var self = Container.call(this);
	self.cardId = '';
	self.rarity = 'common';
	self.level = 1;
	self.cardPoints = 0;
	self.cost = 3;
	self.name = 'Card';
	var cardGraphics = self.attachAsset('commonCard', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var nameText = new Text2('Card', {
		size: 24,
		fill: 0xFFFFFF
	});
	nameText.anchor.set(0.5, 0.5);
	nameText.x = 0;
	nameText.y = -100;
	self.addChild(nameText);
	var levelText = new Text2('Lv 1', {
		size: 20,
		fill: 0xFFFFFF
	});
	levelText.anchor.set(0.5, 0.5);
	levelText.x = 0;
	levelText.y = 80;
	self.addChild(levelText);
	var costText = new Text2('3', {
		size: 32,
		fill: 0xE91E63
	});
	costText.anchor.set(0.5, 0.5);
	costText.x = -70;
	costText.y = -110;
	self.addChild(costText);
	self.setCard = function (cardId, rarity, level, name, cost) {
		self.cardId = cardId;
		self.rarity = rarity;
		self.level = level;
		self.name = name;
		self.cost = cost;
		// Update graphics based on specific card
		self.removeChild(cardGraphics);
		var assetName = cardId + '_card';
		cardGraphics = self.attachAsset(assetName, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		nameText.setText(name);
		levelText.setText('Lv ' + level);
		costText.setText(cost.toString());
	};
	self.down = function (x, y, obj) {
		if (gameState === 'deck' && self.cardId !== '') {
			selectedCard = self;
			LK.getSound('cardFlip').play();
		} else if (gameState === 'battle' && currentElixir >= self.cost && self.cardId !== '') {
			if (!isDeploymentMode) {
				// Enter deployment mode
				selectedHandCard = self;
				isDeploymentMode = true;
				// Show deployment zones
				for (var i = 0; i < deploymentZones.length; i++) {
					deploymentZones[i].alpha = 0.5;
					tween(deploymentZones[i], {
						alpha: 0.8
					}, {
						duration: 300
					});
				}
				// Highlight selected card
				tween(self, {
					scaleX: 1.1,
					scaleY: 1.1
				}, {
					duration: 200
				});
			} else if (selectedHandCard === self) {
				// Cancel deployment
				cancelDeployment();
			}
		}
	};
	return self;
});
var DeckSlot = Container.expand(function () {
	var self = Container.call(this);
	var slotGraphics = self.attachAsset('cardSlot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var plusText = new Text2('+', {
		size: 60,
		fill: 0x888888
	});
	plusText.anchor.set(0.5, 0.5);
	plusText.x = 0;
	plusText.y = 0;
	self.addChild(plusText);
	self.card = null;
	self.slotIndex = 0;
	self.setCard = function (card) {
		if (self.card) {
			self.removeChild(self.card);
		}
		self.card = card;
		if (card) {
			card.x = 0;
			card.y = 0;
			self.addChild(card);
			plusText.alpha = 0;
		} else {
			plusText.alpha = 1;
		}
	};
	self.down = function (x, y, obj) {
		if (gameState === 'deck' && selectedCard) {
			self.setCard(selectedCard);
			currentDeck[self.slotIndex] = selectedCard.cardId;
			selectedCard = null;
			LK.getSound('cardDrop').play();
		}
	};
	return self;
});
var Tower = Container.expand(function () {
	var self = Container.call(this);
	self.towerType = 'player'; // 'player', 'enemy', 'central'
	self.maxHealth = 100;
	self.currentHealth = 100;
	self.isActive = true;
	self.shootRange = 300;
	self.lastShot = 0;
	self.shootCooldown = 60; // 1 second at 60fps
	self.damage = 30;
	var towerGraphics = self.attachAsset('playerTower', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var healthText = new Text2('100', {
		size: 20,
		fill: 0xFFFFFF
	});
	healthText.anchor.set(0.5, 0.5);
	healthText.x = 0;
	healthText.y = -80;
	self.addChild(healthText);
	self.setTowerType = function (type) {
		self.towerType = type;
		self.removeChild(towerGraphics);
		var assetName = type + 'Tower';
		towerGraphics = self.attachAsset(assetName, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		if (type === 'central') {
			self.maxHealth = 200;
			self.currentHealth = 200;
			self.isActive = false; // Starts inactive
			// Make central tower larger
			towerGraphics.scaleX = 1.2;
			towerGraphics.scaleY = 1.2;
		} else {
			// Regular tower size
			towerGraphics.scaleX = 1.0;
			towerGraphics.scaleY = 1.0;
		}
		// Add tower base shadow effect
		var shadowOffset = 8;
		towerGraphics.tint = type === 'player' ? 0x1976d2 : type === 'enemy' ? 0xd32f2f : 0x388e3c;
	};
	self.takeDamage = function (damage) {
		if (self.currentHealth > 0) {
			self.currentHealth -= damage;
			healthText.setText(Math.max(0, self.currentHealth).toString());
			// Flash red when taking damage
			tween(towerGraphics, {
				tint: 0xff0000
			}, {
				duration: 200,
				onFinish: function onFinish() {
					var originalTint = self.towerType === 'player' ? 0x1976d2 : self.towerType === 'enemy' ? 0xd32f2f : 0x388e3c;
					towerGraphics.tint = originalTint;
				}
			});
			if (self.currentHealth <= 0) {
				// Tower destroyed effect
				LK.effects.flashScreen(self.towerType === 'player' ? 0xff0000 : 0x00ff00, 500);
				self.alpha = 0.3;
				if (self.towerType === 'central') {
					// Game over condition
					if (self === playerCentralTower) {
						LK.showGameOver();
					} else if (self === enemyCentralTower) {
						storage.trophies += 50;
						storage.purpleCoins += 100;
						LK.showYouWin();
					}
				}
				return true; // Tower destroyed
			}
		}
		return false;
	};
	self.activate = function () {
		self.isActive = true;
		tween(towerGraphics, {
			tint: 0xffff00
		}, {
			duration: 500
		});
	};
	self.findNearestEnemy = function () {
		if (!allUnits) return null;
		var nearestDistance = self.shootRange;
		var nearestEnemy = null;
		var enemyTeam = self.towerType === 'player' ? 'enemy' : 'player';
		for (var i = 0; i < allUnits.length; i++) {
			var unit = allUnits[i];
			if (unit && unit.isAlive && unit.team === enemyTeam) {
				var distance = Math.sqrt(Math.pow(unit.x - self.x, 2) + Math.pow(unit.y - self.y, 2));
				if (distance < nearestDistance) {
					nearestDistance = distance;
					nearestEnemy = unit;
				}
			}
		}
		return nearestEnemy;
	};
	self.update = function () {
		if (self.isActive && self.currentHealth > 0 && LK.ticks - self.lastShot > self.shootCooldown) {
			var target = self.findNearestEnemy();
			if (target) {
				target.takeDamage(self.damage);
				self.lastShot = LK.ticks;
				// Shooting animation
				tween(self, {
					scaleX: 1.1,
					scaleY: 1.1
				}, {
					duration: 100,
					onFinish: function onFinish() {
						tween(self, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 100
						});
					}
				});
			}
		}
	};
	return self;
});
var Unit = Container.expand(function () {
	var self = Container.call(this);
	self.unitType = 'knight';
	self.team = 'player'; // 'player' or 'enemy'
	self.maxHealth = 100;
	self.currentHealth = 100;
	self.damage = 20;
	self.speed = 2;
	self.range = 60;
	self.attackCooldown = 60; // 1 second at 60fps
	self.lastAttack = 0;
	self.target = null;
	self.isAlive = true;
	self.targetX = 0;
	self.targetY = 0;
	self.isMoving = true;
	var unitGraphics = self.attachAsset('knight_card', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	unitGraphics.scaleX = 0.3;
	unitGraphics.scaleY = 0.3;
	var healthBar = self.attachAsset('elixirBarBg', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	healthBar.scaleX = 0.3;
	healthBar.scaleY = 0.15;
	healthBar.y = -40;
	var healthFill = self.attachAsset('elixirBar', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	healthFill.scaleX = 0.3;
	healthFill.scaleY = 0.15;
	healthFill.y = -40;
	self.setUnitType = function (unitType, team) {
		self.unitType = unitType;
		self.team = team;
		self.removeChild(unitGraphics);
		// Get unit stats from card database
		var cardData = cardDatabase[unitType];
		if (cardData) {
			self.maxHealth = 80 + cardData.baseCost * 20;
			self.currentHealth = self.maxHealth;
			self.damage = 15 + cardData.baseCost * 5;
			// Different unit types have different behaviors
			switch (unitType) {
				case 'knight':
					self.speed = 1.5;
					self.range = 60;
					break;
				case 'archer':
					self.speed = 2;
					self.range = 200;
					break;
				case 'giant':
					self.speed = 1;
					self.range = 60;
					self.maxHealth = 300;
					self.currentHealth = 300;
					break;
				case 'wizard':
					self.speed = 1.8;
					self.range = 180;
					self.damage = 40;
					break;
				default:
					self.speed = 1.5;
					self.range = 80;
			}
		}
		unitGraphics = self.attachAsset(unitType + '_card', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		unitGraphics.scaleX = 0.3;
		unitGraphics.scaleY = 0.3;
		// Set team color
		if (team === 'enemy') {
			unitGraphics.tint = 0xff6666;
		} else {
			unitGraphics.tint = 0x6666ff;
		}
		// Set initial target based on team
		if (team === 'player') {
			// Player units target enemy towers
			if (enemyLeftTower && enemyLeftTower.currentHealth > 0) {
				self.targetX = enemyLeftTower.x;
				self.targetY = enemyLeftTower.y;
			} else if (enemyRightTower && enemyRightTower.currentHealth > 0) {
				self.targetX = enemyRightTower.x;
				self.targetY = enemyRightTower.y;
			} else if (enemyCentralTower && enemyCentralTower.currentHealth > 0) {
				self.targetX = enemyCentralTower.x;
				self.targetY = enemyCentralTower.y;
			}
		} else {
			// Enemy units target player towers
			if (playerLeftTower && playerLeftTower.currentHealth > 0) {
				self.targetX = playerLeftTower.x;
				self.targetY = playerLeftTower.y;
			} else if (playerRightTower && playerRightTower.currentHealth > 0) {
				self.targetX = playerRightTower.x;
				self.targetY = playerRightTower.y;
			} else if (playerCentralTower && playerCentralTower.currentHealth > 0) {
				self.targetX = playerCentralTower.x;
				self.targetY = playerCentralTower.y;
			}
		}
	};
	self.takeDamage = function (damage) {
		if (self.isAlive) {
			self.currentHealth -= damage;
			// Flash red when taking damage
			tween(unitGraphics, {
				tint: 0xff0000
			}, {
				duration: 200,
				onFinish: function onFinish() {
					unitGraphics.tint = self.team === 'enemy' ? 0xff6666 : 0x6666ff;
				}
			});
			if (self.currentHealth <= 0) {
				self.isAlive = false;
				self.destroy();
				return true;
			}
		}
		return false;
	};
	self.findNearestTarget = function () {
		var nearestDistance = 999999;
		var nearestTarget = null;
		// Find nearest enemy unit
		if (allUnits) {
			for (var i = 0; i < allUnits.length; i++) {
				var unit = allUnits[i];
				if (unit && unit.isAlive && unit.team !== self.team) {
					var distance = Math.sqrt(Math.pow(unit.x - self.x, 2) + Math.pow(unit.y - self.y, 2));
					if (distance < nearestDistance && distance <= self.range * 2) {
						nearestDistance = distance;
						nearestTarget = unit;
					}
				}
			}
		}
		// If no units in range, target towers
		if (!nearestTarget) {
			if (self.team === 'player') {
				if (enemyLeftTower && enemyLeftTower.currentHealth > 0) {
					var distToLeft = Math.sqrt(Math.pow(enemyLeftTower.x - self.x, 2) + Math.pow(enemyLeftTower.y - self.y, 2));
					if (distToLeft < nearestDistance) {
						nearestDistance = distToLeft;
						nearestTarget = enemyLeftTower;
					}
				}
				if (enemyRightTower && enemyRightTower.currentHealth > 0) {
					var distToRight = Math.sqrt(Math.pow(enemyRightTower.x - self.x, 2) + Math.pow(enemyRightTower.y - self.y, 2));
					if (distToRight < nearestDistance) {
						nearestDistance = distToRight;
						nearestTarget = enemyRightTower;
					}
				}
				if (enemyCentralTower && enemyCentralTower.currentHealth > 0 && enemyCentralTower.isActive) {
					var distToCentral = Math.sqrt(Math.pow(enemyCentralTower.x - self.x, 2) + Math.pow(enemyCentralTower.y - self.y, 2));
					if (distToCentral < nearestDistance) {
						nearestTarget = enemyCentralTower;
					}
				}
			} else {
				if (playerLeftTower && playerLeftTower.currentHealth > 0) {
					var distToLeft = Math.sqrt(Math.pow(playerLeftTower.x - self.x, 2) + Math.pow(playerLeftTower.y - self.y, 2));
					if (distToLeft < nearestDistance) {
						nearestDistance = distToLeft;
						nearestTarget = playerLeftTower;
					}
				}
				if (playerRightTower && playerRightTower.currentHealth > 0) {
					var distToRight = Math.sqrt(Math.pow(playerRightTower.x - self.x, 2) + Math.pow(playerRightTower.y - self.y, 2));
					if (distToRight < nearestDistance) {
						nearestDistance = distToRight;
						nearestTarget = playerRightTower;
					}
				}
				if (playerCentralTower && playerCentralTower.currentHealth > 0 && playerCentralTower.isActive) {
					var distToCentral = Math.sqrt(Math.pow(playerCentralTower.x - self.x, 2) + Math.pow(playerCentralTower.y - self.y, 2));
					if (distToCentral < nearestDistance) {
						nearestTarget = playerCentralTower;
					}
				}
			}
		}
		return nearestTarget;
	};
	self.update = function () {
		if (!self.isAlive) return;
		// Update health bar
		var healthPercent = self.currentHealth / self.maxHealth;
		healthFill.scaleX = 0.3 * healthPercent;
		// Find target
		self.target = self.findNearestTarget();
		if (self.target) {
			var distance = Math.sqrt(Math.pow(self.target.x - self.x, 2) + Math.pow(self.target.y - self.y, 2));
			if (distance <= self.range) {
				// Attack target
				self.isMoving = false;
				if (LK.ticks - self.lastAttack >= self.attackCooldown) {
					self.target.takeDamage(self.damage);
					self.lastAttack = LK.ticks;
					// Attack animation
					tween(self, {
						scaleX: 1.2,
						scaleY: 1.2
					}, {
						duration: 100,
						onFinish: function onFinish() {
							tween(self, {
								scaleX: 1,
								scaleY: 1
							}, {
								duration: 100
							});
						}
					});
				}
			} else {
				// Move towards target
				self.isMoving = true;
				self.targetX = self.target.x;
				self.targetY = self.target.y;
			}
		}
		// Movement
		if (self.isMoving && self.target) {
			var dx = self.targetX - self.x;
			var dy = self.targetY - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > 5) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game states
// Card Graphics - Common Cards (Gray)
// Card Graphics - Special Cards (Green)
// Card Graphics - Epic Cards (Purple)
// Card Graphics - Legendary Cards (Orange)
var gameState = 'main'; // 'main', 'deck', 'battle', 'shop'
var selectedCard = null;
var currentElixir = 5.0;
var maxElixir = 10.0;
var elixirRegenRate = 1.0; // per second
var lastElixirUpdate = 0;
// Battle arena elements
var battleArena = null;
var river = null;
var leftBridge = null;
var rightBridge = null;
var playerLeftTower = null;
var playerRightTower = null;
var playerCentralTower = null;
var enemyLeftTower = null;
var enemyRightTower = null;
var enemyCentralTower = null;
var deploymentZones = [];
var selectedHandCard = null;
var isDeploymentMode = false;
// Unit management
var allUnits = [];
var enemyElixir = 5.0;
var lastEnemyDeploy = 0;
var enemyDeckCards = ['knight', 'archer', 'giant', 'wizard', 'goblin', 'barbarian', 'minion', 'fireball'];
// Arena data
var arenas = [{
	name: 'Training Camp',
	trophiesRequired: 0,
	color: 0x4caf50
}, {
	name: 'Goblin Stadium',
	trophiesRequired: 400,
	color: 0xff9800
}, {
	name: 'Bone Pit',
	trophiesRequired: 800,
	color: 0x795548
}, {
	name: 'Barbarian Bowl',
	trophiesRequired: 1100,
	color: 0xf44336
}, {
	name: 'P.E.K.K.A Playhouse',
	trophiesRequired: 1400,
	color: 0x9c27b0
}, {
	name: 'Spell Valley',
	trophiesRequired: 1700,
	color: 0x673ab7
}, {
	name: 'Builder Workshop',
	trophiesRequired: 2000,
	color: 0x3f51b5
}, {
	name: 'Royal Arena',
	trophiesRequired: 2300,
	color: 0x2196f3
}, {
	name: 'Frozen Peak',
	trophiesRequired: 2600,
	color: 0x00bcd4
}, {
	name: 'Jungle Arena',
	trophiesRequired: 2900,
	color: 0x4caf50
}, {
	name: 'Hog Mountain',
	trophiesRequired: 3200,
	color: 0x8bc34a
}, {
	name: 'Legendary Arena',
	trophiesRequired: 3500,
	color: 0xffc107
}];
// Comprehensive cards database with graphics
var cardDatabase = {
	// COMMON CARDS (30) - Base level 1
	'knight': {
		name: 'Knight',
		rarity: 'common',
		baseCost: 3,
		baseLevel: 1
	},
	'archer': {
		name: 'Archer',
		rarity: 'common',
		baseCost: 3,
		baseLevel: 1
	},
	'goblin': {
		name: 'Goblin',
		rarity: 'common',
		baseCost: 2,
		baseLevel: 1
	},
	'skeleton': {
		name: 'Skeleton',
		rarity: 'common',
		baseCost: 1,
		baseLevel: 1
	},
	'spearman': {
		name: 'Spearman',
		rarity: 'common',
		baseCost: 2,
		baseLevel: 1
	},
	'barbarian': {
		name: 'Barbarian',
		rarity: 'common',
		baseCost: 5,
		baseLevel: 1
	},
	'minion': {
		name: 'Minion',
		rarity: 'common',
		baseCost: 3,
		baseLevel: 1
	},
	'bomber': {
		name: 'Bomber',
		rarity: 'common',
		baseCost: 3,
		baseLevel: 1
	},
	'swordsman': {
		name: 'Swordsman',
		rarity: 'common',
		baseCost: 4,
		baseLevel: 1
	},
	'shield_guard': {
		name: 'Shield Guard',
		rarity: 'common',
		baseCost: 3,
		baseLevel: 1
	},
	'crossbow_archer': {
		name: 'Crossbow Archer',
		rarity: 'common',
		baseCost: 4,
		baseLevel: 1
	},
	'horse_rider': {
		name: 'Horse Rider',
		rarity: 'common',
		baseCost: 4,
		baseLevel: 1
	},
	'fire_spirit': {
		name: 'Fire Spirit',
		rarity: 'common',
		baseCost: 1,
		baseLevel: 1
	},
	'ice_spirit': {
		name: 'Ice Spirit',
		rarity: 'common',
		baseCost: 1,
		baseLevel: 1
	},
	'mage_apprentice': {
		name: 'Mage Apprentice',
		rarity: 'common',
		baseCost: 3,
		baseLevel: 1
	},
	'royal_guard': {
		name: 'Royal Guard',
		rarity: 'common',
		baseCost: 3,
		baseLevel: 1
	},
	'battle_ram': {
		name: 'Battle Ram',
		rarity: 'common',
		baseCost: 4,
		baseLevel: 1
	},
	'cannon': {
		name: 'Cannon',
		rarity: 'common',
		baseCost: 3,
		baseLevel: 1
	},
	'mortar': {
		name: 'Mortar',
		rarity: 'common',
		baseCost: 4,
		baseLevel: 1
	},
	'tesla_tower': {
		name: 'Tesla Tower',
		rarity: 'common',
		baseCost: 4,
		baseLevel: 1
	},
	'heal_potion': {
		name: 'Heal Potion',
		rarity: 'common',
		baseCost: 3,
		baseLevel: 1
	},
	'speed_boost': {
		name: 'Speed Boost',
		rarity: 'common',
		baseCost: 2,
		baseLevel: 1
	},
	'arrows': {
		name: 'Arrows',
		rarity: 'common',
		baseCost: 3,
		baseLevel: 1
	},
	'fireball': {
		name: 'Fireball',
		rarity: 'common',
		baseCost: 4,
		baseLevel: 1
	},
	'zap': {
		name: 'Zap',
		rarity: 'common',
		baseCost: 2,
		baseLevel: 1
	},
	'ice_bolt': {
		name: 'Ice Bolt',
		rarity: 'common',
		baseCost: 2,
		baseLevel: 1
	},
	'poison_cloud': {
		name: 'Poison Cloud',
		rarity: 'common',
		baseCost: 4,
		baseLevel: 1
	},
	'stone_wall': {
		name: 'Stone Wall',
		rarity: 'common',
		baseCost: 3,
		baseLevel: 1
	},
	'wooden_spikes': {
		name: 'Wooden Spikes',
		rarity: 'common',
		baseCost: 2,
		baseLevel: 1
	},
	'village_militia': {
		name: 'Village Militia',
		rarity: 'common',
		baseCost: 2,
		baseLevel: 1
	},
	// SPECIAL CARDS (15) - Base level 3
	'giant': {
		name: 'Giant',
		rarity: 'special',
		baseCost: 5,
		baseLevel: 3
	},
	'wizard': {
		name: 'Wizard',
		rarity: 'special',
		baseCost: 5,
		baseLevel: 3
	},
	'valkyrie': {
		name: 'Valkyrie',
		rarity: 'special',
		baseCost: 4,
		baseLevel: 3
	},
	'musketeer': {
		name: 'Musketeer',
		rarity: 'special',
		baseCost: 4,
		baseLevel: 3
	},
	'baby_dragon': {
		name: 'Baby Dragon',
		rarity: 'special',
		baseCost: 4,
		baseLevel: 3
	},
	'mini_pekka': {
		name: 'Mini P.E.K.K.A',
		rarity: 'special',
		baseCost: 4,
		baseLevel: 3
	},
	'hog_rider': {
		name: 'Hog Rider',
		rarity: 'special',
		baseCost: 4,
		baseLevel: 3
	},
	'balloon': {
		name: 'Balloon',
		rarity: 'special',
		baseCost: 5,
		baseLevel: 3
	},
	'freeze': {
		name: 'Freeze',
		rarity: 'special',
		baseCost: 4,
		baseLevel: 3
	},
	'rage': {
		name: 'Rage',
		rarity: 'special',
		baseCost: 2,
		baseLevel: 3
	},
	'mirror': {
		name: 'Mirror',
		rarity: 'special',
		baseCost: 1,
		baseLevel: 3
	},
	'elixir_collector': {
		name: 'Elixir Collector',
		rarity: 'special',
		baseCost: 6,
		baseLevel: 3
	},
	'tombstone': {
		name: 'Tombstone',
		rarity: 'special',
		baseCost: 3,
		baseLevel: 3
	},
	'bomb_tower': {
		name: 'Bomb Tower',
		rarity: 'special',
		baseCost: 5,
		baseLevel: 3
	},
	'inferno_tower': {
		name: 'Inferno Tower',
		rarity: 'special',
		baseCost: 5,
		baseLevel: 3
	},
	// EPIC CARDS (10) - Base level 6
	'prince': {
		name: 'Prince',
		rarity: 'epic',
		baseCost: 5,
		baseLevel: 6
	},
	'pekka': {
		name: 'P.E.K.K.A',
		rarity: 'epic',
		baseCost: 7,
		baseLevel: 6
	},
	'dark_prince': {
		name: 'Dark Prince',
		rarity: 'epic',
		baseCost: 4,
		baseLevel: 6
	},
	'golem': {
		name: 'Golem',
		rarity: 'epic',
		baseCost: 8,
		baseLevel: 6
	},
	'witch': {
		name: 'Witch',
		rarity: 'epic',
		baseCost: 5,
		baseLevel: 6
	},
	'skeleton_army': {
		name: 'Skeleton Army',
		rarity: 'epic',
		baseCost: 3,
		baseLevel: 6
	},
	'lightning': {
		name: 'Lightning',
		rarity: 'epic',
		baseCost: 6,
		baseLevel: 6
	},
	'rocket': {
		name: 'Rocket',
		rarity: 'epic',
		baseCost: 6,
		baseLevel: 6
	},
	'x_bow': {
		name: 'X-Bow',
		rarity: 'epic',
		baseCost: 6,
		baseLevel: 6
	},
	'giant_skeleton': {
		name: 'Giant Skeleton',
		rarity: 'epic',
		baseCost: 6,
		baseLevel: 6
	},
	// LEGENDARY CARDS (7) - Base level 9
	'princess': {
		name: 'Princess',
		rarity: 'legendary',
		baseCost: 3,
		baseLevel: 9
	},
	'dragon': {
		name: 'Dragon',
		rarity: 'legendary',
		baseCost: 4,
		baseLevel: 9
	},
	'ice_wizard': {
		name: 'Ice Wizard',
		rarity: 'legendary',
		baseCost: 3,
		baseLevel: 9
	},
	'lava_hound': {
		name: 'Lava Hound',
		rarity: 'legendary',
		baseCost: 7,
		baseLevel: 9
	},
	'miner': {
		name: 'Miner',
		rarity: 'legendary',
		baseCost: 3,
		baseLevel: 9
	},
	'sparky': {
		name: 'Sparky',
		rarity: 'legendary',
		baseCost: 6,
		baseLevel: 9
	},
	'lumberjack': {
		name: 'Lumberjack',
		rarity: 'legendary',
		baseCost: 4,
		baseLevel: 9
	}
};
// Initialize owned cards if not exist
if (!storage.ownedCards || Object.keys(storage.ownedCards).length === 0) {
	storage.ownedCards = {
		// Starting common cards
		'knight': {
			level: 1,
			points: 0
		},
		'archer': {
			level: 1,
			points: 0
		},
		'goblin': {
			level: 1,
			points: 0
		},
		'skeleton': {
			level: 1,
			points: 0
		},
		'spearman': {
			level: 1,
			points: 0
		},
		'barbarian': {
			level: 1,
			points: 0
		},
		'minion': {
			level: 1,
			points: 0
		},
		'fireball': {
			level: 1,
			points: 0
		},
		// Starting special cards
		'giant': {
			level: 3,
			points: 0
		},
		'wizard': {
			level: 3,
			points: 0
		},
		'valkyrie': {
			level: 3,
			points: 0
		},
		'musketeer': {
			level: 3,
			points: 0
		},
		// Starting epic cards
		'prince': {
			level: 6,
			points: 0
		},
		'witch': {
			level: 6,
			points: 0
		},
		// Starting legendary card
		'princess': {
			level: 9,
			points: 0
		}
	};
}
// Initialize deck if not exist
if (!storage.deck || storage.deck.length === 0) {
	storage.deck = ['knight', 'archer', 'giant', 'wizard', 'prince', 'princess', 'fireball', 'barbarian'];
}
var currentDeck = storage.deck.slice();
var currentArena = Math.min(getCurrentArena(), arenas.length - 1);
// UI Elements
var titleText = new Text2('CEXLA', {
	size: 80,
	fill: 0xFFFFFF
});
titleText.anchor.set(0.5, 0.5);
var arenaText = new Text2('', {
	size: 36,
	fill: 0xFFFFFF
});
arenaText.anchor.set(0.5, 0.5);
var trophiesText = new Text2('', {
	size: 24,
	fill: 0xFFC107
});
trophiesText.anchor.set(0.5, 0.5);
var coinsText = new Text2('', {
	size: 24,
	fill: 0x9C27B0
});
coinsText.anchor.set(0.5, 0.5);
var gemsText = new Text2('', {
	size: 24,
	fill: 0x2196F3
});
gemsText.anchor.set(0.5, 0.5);
// Buttons
var battleButton = game.addChild(LK.getAsset('battleButton', {
	anchorX: 0.5,
	anchorY: 0.5
}));
var deckButton = game.addChild(LK.getAsset('deckButton', {
	anchorX: 0.5,
	anchorY: 0.5
}));
var shopButton = game.addChild(LK.getAsset('shopButton', {
	anchorX: 0.5,
	anchorY: 0.5
}));
var backButton = game.addChild(LK.getAsset('menuButton', {
	anchorX: 0.5,
	anchorY: 0.5
}));
// Battle UI
var elixirBarBg = game.addChild(LK.getAsset('elixirBarBg', {
	anchorX: 0.5,
	anchorY: 0.5
}));
var elixirBar = game.addChild(LK.getAsset('elixirBar', {
	anchorX: 0.5,
	anchorY: 0.5
}));
var elixirText = new Text2('5/10', {
	size: 20,
	fill: 0xFFFFFF
});
elixirText.anchor.set(0.5, 0.5);
// Deck slots for deck builder
var deckSlots = [];
for (var i = 0; i < 8; i++) {
	var slot = new DeckSlot();
	slot.slotIndex = i;
	deckSlots.push(slot);
	game.addChild(slot);
}
// Card collection for deck builder
var cardCollection = [];
var cardCollectionContainer = new Container();
game.addChild(cardCollectionContainer);
// Battle hand cards
var handCards = [];
for (var j = 0; j < 4; j++) {
	var handCard = new Card();
	handCards.push(handCard);
	game.addChild(handCard);
}
// Add text elements to GUI
LK.gui.top.addChild(titleText);
LK.gui.top.addChild(arenaText);
LK.gui.top.addChild(trophiesText);
LK.gui.top.addChild(coinsText);
LK.gui.top.addChild(gemsText);
LK.gui.bottom.addChild(elixirText);
// Button texts
var battleButtonText = new Text2('BATTLE', {
	size: 32,
	fill: 0xFFFFFF
});
battleButtonText.anchor.set(0.5, 0.5);
battleButton.addChild(battleButtonText);
var deckButtonText = new Text2('DECK', {
	size: 24,
	fill: 0xFFFFFF
});
deckButtonText.anchor.set(0.5, 0.5);
deckButton.addChild(deckButtonText);
var shopButtonText = new Text2('SHOP', {
	size: 24,
	fill: 0xFFFFFF
});
shopButtonText.anchor.set(0.5, 0.5);
shopButton.addChild(shopButtonText);
var backButtonText = new Text2('BACK', {
	size: 20,
	fill: 0xFFFFFF
});
backButtonText.anchor.set(0.5, 0.5);
backButton.addChild(backButtonText);
// Functions
function getCurrentArena() {
	var arena = 0;
	for (var i = arenas.length - 1; i >= 0; i--) {
		if (storage.trophies >= arenas[i].trophiesRequired) {
			arena = i;
			break;
		}
	}
	return arena;
}
function updateUI() {
	currentArena = getCurrentArena();
	var nextArena = Math.min(currentArena + 1, arenas.length - 1);
	var progress = 0;
	if (currentArena < arenas.length - 1) {
		var currentReq = arenas[currentArena].trophiesRequired;
		var nextReq = arenas[nextArena].trophiesRequired;
		progress = Math.floor((storage.trophies - currentReq) / (nextReq - currentReq) * 100);
	} else {
		progress = 100;
	}
	arenaText.setText(arenas[currentArena].name);
	trophiesText.setText('🏆 ' + storage.trophies + ' (' + progress + '%)');
	coinsText.setText('💰 ' + storage.purpleCoins);
	gemsText.setText('💎 ' + storage.blueGems);
	elixirText.setText(Math.floor(currentElixir) + '/' + maxElixir);
}
function showMainMenu() {
	gameState = 'main';
	// Position elements for main menu
	titleText.x = 0;
	titleText.y = 100;
	arenaText.x = 0;
	arenaText.y = 200;
	trophiesText.x = 0;
	trophiesText.y = 250;
	coinsText.x = -100;
	coinsText.y = 300;
	gemsText.x = 100;
	gemsText.y = 300;
	battleButton.x = 1024;
	battleButton.y = 1800;
	battleButton.alpha = 1;
	deckButton.x = 700;
	deckButton.y = 1900;
	deckButton.alpha = 1;
	shopButton.x = 1348;
	shopButton.y = 1900;
	shopButton.alpha = 1;
	backButton.alpha = 0;
	// Clean up deployment mode
	cancelDeployment();
	// Hide and clean up battle arena elements
	if (battleArena) {
		battleArena.alpha = 0;
	}
	if (river) {
		river.alpha = 0;
	}
	if (leftBridge) {
		leftBridge.alpha = 0;
	}
	if (rightBridge) {
		rightBridge.alpha = 0;
	}
	if (playerLeftTower) {
		playerLeftTower.alpha = 0;
	}
	if (playerRightTower) {
		playerRightTower.alpha = 0;
	}
	if (playerCentralTower) {
		playerCentralTower.alpha = 0;
	}
	if (enemyLeftTower) {
		enemyLeftTower.alpha = 0;
	}
	if (enemyRightTower) {
		enemyRightTower.alpha = 0;
	}
	if (enemyCentralTower) {
		enemyCentralTower.alpha = 0;
	}
	// Hide deck builder elements
	for (var i = 0; i < deckSlots.length; i++) {
		deckSlots[i].alpha = 0;
	}
	cardCollectionContainer.alpha = 0;
	// Hide battle elements
	for (var j = 0; j < handCards.length; j++) {
		handCards[j].alpha = 0;
	}
	elixirBarBg.alpha = 0;
	elixirBar.alpha = 0;
	elixirText.alpha = 0;
}
function showDeckBuilder() {
	gameState = 'deck';
	titleText.alpha = 0;
	arenaText.alpha = 0;
	trophiesText.alpha = 0;
	coinsText.alpha = 0;
	gemsText.alpha = 0;
	battleButton.alpha = 0;
	deckButton.alpha = 0;
	shopButton.alpha = 0;
	backButton.x = 1800;
	backButton.y = 200;
	backButton.alpha = 1;
	// Position deck slots
	for (var i = 0; i < 8; i++) {
		var col = i % 4;
		var row = Math.floor(i / 4);
		deckSlots[i].x = 300 + col * 220;
		deckSlots[i].y = 400 + row * 320;
		deckSlots[i].alpha = 1;
		// Load existing deck card
		if (currentDeck[i] && cardDatabase[currentDeck[i]]) {
			var cardData = cardDatabase[currentDeck[i]];
			var ownedData = storage.ownedCards[currentDeck[i]];
			if (ownedData) {
				var deckCard = new Card();
				deckCard.setCard(currentDeck[i], cardData.rarity, ownedData.level, cardData.name, cardData.baseCost);
				deckSlots[i].setCard(deckCard);
			}
		}
	}
	// Setup card collection
	cardCollectionContainer.alpha = 1;
	setupCardCollection();
	// Hide battle elements
	for (var j = 0; j < handCards.length; j++) {
		handCards[j].alpha = 0;
	}
	elixirBarBg.alpha = 0;
	elixirBar.alpha = 0;
	elixirText.alpha = 0;
}
function setupCardCollection() {
	// Clear existing collection
	while (cardCollectionContainer.children.length > 0) {
		cardCollectionContainer.removeChild(cardCollectionContainer.children[0]);
	}
	cardCollection = [];
	var cardIndex = 0;
	for (var cardId in storage.ownedCards) {
		if (cardDatabase[cardId]) {
			var cardData = cardDatabase[cardId];
			var ownedData = storage.ownedCards[cardId];
			var collectionCard = new Card();
			collectionCard.setCard(cardId, cardData.rarity, ownedData.level, cardData.name, cardData.baseCost);
			var col = cardIndex % 8;
			var row = Math.floor(cardIndex / 8);
			collectionCard.x = 150 + col * 200;
			collectionCard.y = 1200 + row * 300;
			cardCollection.push(collectionCard);
			cardCollectionContainer.addChild(collectionCard);
			cardIndex++;
		}
	}
}
function showBattle() {
	gameState = 'battle';
	titleText.alpha = 0;
	arenaText.alpha = 0;
	trophiesText.alpha = 0;
	coinsText.alpha = 0;
	gemsText.alpha = 0;
	battleButton.alpha = 0;
	deckButton.alpha = 0;
	shopButton.alpha = 0;
	backButton.x = 1800;
	backButton.y = 200;
	backButton.alpha = 1;
	// Hide deck builder elements
	for (var i = 0; i < deckSlots.length; i++) {
		deckSlots[i].alpha = 0;
	}
	cardCollectionContainer.alpha = 0;
	// Setup battle arena
	setupBattleArena();
	// Show battle elements
	elixirBarBg.x = 1024;
	elixirBarBg.y = 2600;
	elixirBarBg.alpha = 1;
	elixirBar.x = 1024;
	elixirBar.y = 2600;
	elixirBar.alpha = 1;
	elixirText.x = 0;
	elixirText.y = -50;
	elixirText.alpha = 1;
	// Setup hand cards
	setupBattleHand();
	currentElixir = 5.0;
}
function setupBattleArena() {
	// Create battle arena background with proper grass-like appearance
	battleArena = game.addChild(LK.getAsset('battleArena', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	battleArena.x = 1024;
	battleArena.y = 1366; // Center vertically in screen
	battleArena.alpha = 1;
	// Create horizontal river crossing the battlefield from left to right
	river = game.addChild(LK.getAsset('river', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	river.x = 1024; // Center horizontally
	river.y = 1366; // Center vertically on screen
	river.alpha = 1;
	// Create left bridge crossing the horizontal river
	leftBridge = game.addChild(LK.getAsset('bridge', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	leftBridge.x = 700; // Left side of battlefield
	leftBridge.y = 1366; // Same Y as river
	leftBridge.alpha = 1;
	// Create right bridge crossing the horizontal river
	rightBridge = game.addChild(LK.getAsset('bridge', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	rightBridge.x = 1348; // Right side of battlefield
	rightBridge.y = 1366; // Same Y as river
	rightBridge.alpha = 1;
	// Create player towers (bottom side of battlefield)
	playerLeftTower = game.addChild(new Tower());
	playerLeftTower.setTowerType('player');
	playerLeftTower.x = 600; // Bottom left position
	playerLeftTower.y = 1800; // Player's back line
	playerLeftTower.alpha = 1;
	playerRightTower = game.addChild(new Tower());
	playerRightTower.setTowerType('player');
	playerRightTower.x = 1448; // Bottom right position
	playerRightTower.y = 1800; // Player's back line
	playerRightTower.alpha = 1;
	playerCentralTower = game.addChild(new Tower());
	playerCentralTower.setTowerType('central');
	playerCentralTower.x = 1024; // Center position
	playerCentralTower.y = 2000; // Behind side towers
	playerCentralTower.alpha = 1;
	// Create enemy towers (top side of battlefield)
	enemyLeftTower = game.addChild(new Tower());
	enemyLeftTower.setTowerType('enemy');
	enemyLeftTower.x = 600; // Top left position
	enemyLeftTower.y = 932; // Enemy's back line
	enemyLeftTower.alpha = 1;
	enemyRightTower = game.addChild(new Tower());
	enemyRightTower.setTowerType('enemy');
	enemyRightTower.x = 1448; // Top right position
	enemyRightTower.y = 932; // Enemy's back line
	enemyRightTower.alpha = 1;
	enemyCentralTower = game.addChild(new Tower());
	enemyCentralTower.setTowerType('central');
	enemyCentralTower.x = 1024; // Center position
	enemyCentralTower.y = 732; // Behind side towers
	enemyCentralTower.alpha = 1;
	// Create deployment zones for visual feedback in player area
	deploymentZones = [];
	for (var i = 0; i < 24; i++) {
		var zone = game.addChild(LK.getAsset('deploymentZone', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		zone.alpha = 0; // Hidden by default
		deploymentZones.push(zone);
	}
	// Position deployment zones in player area (below river)
	var zoneIndex = 0;
	for (var row = 0; row < 4; row++) {
		for (var col = 0; col < 6; col++) {
			if (zoneIndex < deploymentZones.length) {
				deploymentZones[zoneIndex].x = 350 + col * 230;
				deploymentZones[zoneIndex].y = 1500 + row * 120;
				zoneIndex++;
			}
		}
	}
	// Add visual enhancements to the map
	// Create river banks for more realistic look
	var topRiverBank = game.addChild(LK.getAsset('riverBank', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	topRiverBank.x = 1024;
	topRiverBank.y = 1266; // Top edge of river
	topRiverBank.alpha = 1;
	var bottomRiverBank = game.addChild(LK.getAsset('riverBank', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	bottomRiverBank.x = 1024;
	bottomRiverBank.y = 1466; // Bottom edge of river
	bottomRiverBank.alpha = 1;
	// Create map borders
	var topBorder = game.addChild(LK.getAsset('mapBorder', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	topBorder.x = 1024;
	topBorder.y = 650;
	topBorder.alpha = 1;
	var bottomBorder = game.addChild(LK.getAsset('mapBorder', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	bottomBorder.x = 1024;
	bottomBorder.y = 2082;
	bottomBorder.alpha = 1;
}
function setupBattleHand() {
	var validCards = currentDeck.filter(function (cardId) {
		return cardId !== '' && cardDatabase[cardId] && storage.ownedCards[cardId];
	});
	for (var i = 0; i < 4; i++) {
		if (validCards.length > i) {
			var cardId = validCards[i];
			var cardData = cardDatabase[cardId];
			var ownedData = storage.ownedCards[cardId];
			handCards[i].setCard(cardId, cardData.rarity, ownedData.level, cardData.name, cardData.baseCost);
			handCards[i].x = 400 + i * 220;
			handCards[i].y = 2400;
			handCards[i].alpha = 1;
		} else {
			handCards[i].alpha = 0;
		}
	}
}
function deployCard(card, deployX, deployY) {
	if (currentElixir >= card.cost) {
		currentElixir -= card.cost;
		// Flash the card
		LK.effects.flashObject(card, 0xffffff, 300);
		// Create deployment effect
		LK.effects.flashScreen(0x00ff00, 200);
		// Create actual unit
		var unit = new Unit();
		unit.setUnitType(card.cardId, 'player');
		unit.x = deployX;
		unit.y = deployY;
		allUnits.push(unit);
		game.addChild(unit);
		// Unit deploy effect
		LK.getSound('unitDeploy').play();
		tween(unit, {
			scaleX: 0,
			scaleY: 0
		}, {
			duration: 0
		});
		tween(unit, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 300,
			easing: tween.bounceOut
		});
		// Rotate hand (simple simulation)
		var nextCardIndex = Math.floor(Math.random() * currentDeck.filter(function (c) {
			return c !== '';
		}).length);
		var validCards = currentDeck.filter(function (cardId) {
			return cardId !== '' && cardDatabase[cardId] && storage.ownedCards[cardId];
		});
		if (validCards.length > 0) {
			var newCardId = validCards[nextCardIndex];
			var cardData = cardDatabase[newCardId];
			var ownedData = storage.ownedCards[newCardId];
			card.setCard(newCardId, cardData.rarity, ownedData.level, cardData.name, cardData.baseCost);
		}
		LK.getSound('cardDrop').play();
	}
}
function cancelDeployment() {
	if (selectedHandCard) {
		tween(selectedHandCard, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 200
		});
		selectedHandCard = null;
	}
	isDeploymentMode = false;
	// Hide deployment zones
	for (var i = 0; i < deploymentZones.length; i++) {
		tween(deploymentZones[i], {
			alpha: 0
		}, {
			duration: 300
		});
	}
}
function checkValidDeployment(x, y) {
	// Check if position is in player's deployment area (bottom half, not crossing river)
	if (y > 1100 && y < 1900 && x > 200 && x < 1848) {
		// Check if not too close to bridges (can't cross)
		if ((x < 624 || x > 824) && (x < 1224 || x > 1424)) {
			return true;
		}
	}
	return false;
}
function deployEnemyCard(cardId, deployX, deployY) {
	if (enemyElixir >= cardDatabase[cardId].baseCost) {
		enemyElixir -= cardDatabase[cardId].baseCost;
		// Create enemy unit
		var unit = new Unit();
		unit.setUnitType(cardId, 'enemy');
		unit.x = deployX;
		unit.y = deployY;
		allUnits.push(unit);
		game.addChild(unit);
		// Enemy deployment effect
		LK.effects.flashScreen(0xff4444, 200);
	}
}
function enemyAI() {
	// Enemy deploys cards every 3-8 seconds based on pressure
	if (LK.ticks - lastEnemyDeploy > 180 + Math.random() * 300) {
		if (enemyElixir >= 3) {
			// Choose deployment strategy
			var playerUnitsNearTower = 0;
			for (var i = 0; i < allUnits.length; i++) {
				if (allUnits[i] && allUnits[i].team === 'player' && allUnits[i].y < 1200) {
					playerUnitsNearTower++;
				}
			}
			var cardToPlay = '';
			var deployX = 0;
			var deployY = 0;
			if (playerUnitsNearTower > 2) {
				// Defensive play - deploy area defense units
				cardToPlay = enemyDeckCards[Math.floor(Math.random() * 4)]; // Prefer cheaper units
				deployX = 500 + Math.random() * 1000;
				deployY = 800 + Math.random() * 200;
			} else {
				// Offensive play - deploy near bridges to attack
				cardToPlay = enemyDeckCards[Math.floor(Math.random() * enemyDeckCards.length)];
				if (Math.random() < 0.5) {
					deployX = 700; // Left bridge
				} else {
					deployX = 1348; // Right bridge
				}
				deployY = 1000 + Math.random() * 100;
			}
			if (cardDatabase[cardToPlay]) {
				deployEnemyCard(cardToPlay, deployX, deployY);
				lastEnemyDeploy = LK.ticks;
			}
		}
	}
}
// Add game click handler for deployment
game.down = function (x, y, obj) {
	if (gameState === 'battle' && isDeploymentMode && selectedHandCard) {
		if (checkValidDeployment(x, y)) {
			deployCard(selectedHandCard, x, y);
			cancelDeployment();
		} else {
			// Invalid deployment area - flash red
			LK.effects.flashScreen(0xff0000, 200);
		}
	}
};
// Button handlers
battleButton.down = function (x, y, obj) {
	if (gameState === 'main') {
		LK.getSound('buttonClick').play();
		showBattle();
	}
};
deckButton.down = function (x, y, obj) {
	if (gameState === 'main') {
		LK.getSound('buttonClick').play();
		showDeckBuilder();
	}
};
shopButton.down = function (x, y, obj) {
	if (gameState === 'main') {
		LK.getSound('buttonClick').play();
		// Shop functionality to be implemented
	}
};
backButton.down = function (x, y, obj) {
	if (gameState !== 'main') {
		LK.getSound('buttonClick').play();
		storage.deck = currentDeck.slice(); // Save deck changes
		showMainMenu();
	}
};
// Initialize game state
showMainMenu();
updateUI();
// Game update loop
game.update = function () {
	updateUI();
	// Update elixir in battle
	if (gameState === 'battle') {
		if (LK.ticks - lastElixirUpdate >= 60) {
			// 1 second at 60 FPS
			if (currentElixir < maxElixir) {
				currentElixir = Math.min(currentElixir + elixirRegenRate, maxElixir);
			}
			if (enemyElixir < maxElixir) {
				enemyElixir = Math.min(enemyElixir + elixirRegenRate, maxElixir);
			}
			lastElixirUpdate = LK.ticks;
		}
		// Update elixir bar visual
		var elixirPercent = currentElixir / maxElixir;
		elixirBar.scaleX = elixirPercent;
		// Clean up destroyed units
		for (var i = allUnits.length - 1; i >= 0; i--) {
			if (!allUnits[i] || !allUnits[i].isAlive) {
				allUnits.splice(i, 1);
			}
		}
		// Enemy AI
		enemyAI();
		// Check tower destruction and activate central towers
		if (playerLeftTower && playerLeftTower.currentHealth <= 0 && playerCentralTower && !playerCentralTower.isActive) {
			playerCentralTower.activate();
		}
		if (playerRightTower && playerRightTower.currentHealth <= 0 && playerCentralTower && !playerCentralTower.isActive) {
			playerCentralTower.activate();
		}
		if (enemyLeftTower && enemyLeftTower.currentHealth <= 0 && enemyCentralTower && !enemyCentralTower.isActive) {
			enemyCentralTower.activate();
		}
		if (enemyRightTower && enemyRightTower.currentHealth <= 0 && enemyCentralTower && !enemyCentralTower.isActive) {
			enemyCentralTower.activate();
		}
		// Victory/Defeat conditions
		if (gameState === 'battle' && LK.ticks % 60 === 0) {
			// Check every second for game end conditions
			if (playerCentralTower && playerCentralTower.currentHealth <= 0) {
				// Player loses
				setTimeout(function () {
					LK.showGameOver();
				}, 1000);
			} else if (enemyCentralTower && enemyCentralTower.currentHealth <= 0) {
				// Player wins
				storage.trophies += 30;
				storage.purpleCoins += 100;
				setTimeout(function () {
					LK.showYouWin();
				}, 1000);
			}
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -149,8 +149,9 @@
 	self.isActive = true;
 	self.shootRange = 300;
 	self.lastShot = 0;
 	self.shootCooldown = 60; // 1 second at 60fps
+	self.damage = 30;
 	var towerGraphics = self.attachAsset('playerTower', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
@@ -189,10 +190,32 @@
 	self.takeDamage = function (damage) {
 		if (self.currentHealth > 0) {
 			self.currentHealth -= damage;
 			healthText.setText(Math.max(0, self.currentHealth).toString());
+			// Flash red when taking damage
+			tween(towerGraphics, {
+				tint: 0xff0000
+			}, {
+				duration: 200,
+				onFinish: function onFinish() {
+					var originalTint = self.towerType === 'player' ? 0x1976d2 : self.towerType === 'enemy' ? 0xd32f2f : 0x388e3c;
+					towerGraphics.tint = originalTint;
+				}
+			});
 			if (self.currentHealth <= 0) {
-				self.destroy();
+				// Tower destroyed effect
+				LK.effects.flashScreen(self.towerType === 'player' ? 0xff0000 : 0x00ff00, 500);
+				self.alpha = 0.3;
+				if (self.towerType === 'central') {
+					// Game over condition
+					if (self === playerCentralTower) {
+						LK.showGameOver();
+					} else if (self === enemyCentralTower) {
+						storage.trophies += 50;
+						storage.purpleCoins += 100;
+						LK.showYouWin();
+					}
+				}
 				return true; // Tower destroyed
 			}
 		}
 		return false;
@@ -204,16 +227,297 @@
 		}, {
 			duration: 500
 		});
 	};
+	self.findNearestEnemy = function () {
+		if (!allUnits) return null;
+		var nearestDistance = self.shootRange;
+		var nearestEnemy = null;
+		var enemyTeam = self.towerType === 'player' ? 'enemy' : 'player';
+		for (var i = 0; i < allUnits.length; i++) {
+			var unit = allUnits[i];
+			if (unit && unit.isAlive && unit.team === enemyTeam) {
+				var distance = Math.sqrt(Math.pow(unit.x - self.x, 2) + Math.pow(unit.y - self.y, 2));
+				if (distance < nearestDistance) {
+					nearestDistance = distance;
+					nearestEnemy = unit;
+				}
+			}
+		}
+		return nearestEnemy;
+	};
 	self.update = function () {
-		if (self.isActive && LK.ticks - self.lastShot > self.shootCooldown) {
-			// Simple shooting simulation
-			self.lastShot = LK.ticks;
+		if (self.isActive && self.currentHealth > 0 && LK.ticks - self.lastShot > self.shootCooldown) {
+			var target = self.findNearestEnemy();
+			if (target) {
+				target.takeDamage(self.damage);
+				self.lastShot = LK.ticks;
+				// Shooting animation
+				tween(self, {
+					scaleX: 1.1,
+					scaleY: 1.1
+				}, {
+					duration: 100,
+					onFinish: function onFinish() {
+						tween(self, {
+							scaleX: 1,
+							scaleY: 1
+						}, {
+							duration: 100
+						});
+					}
+				});
+			}
 		}
 	};
 	return self;
 });
+var Unit = Container.expand(function () {
+	var self = Container.call(this);
+	self.unitType = 'knight';
+	self.team = 'player'; // 'player' or 'enemy'
+	self.maxHealth = 100;
+	self.currentHealth = 100;
+	self.damage = 20;
+	self.speed = 2;
+	self.range = 60;
+	self.attackCooldown = 60; // 1 second at 60fps
+	self.lastAttack = 0;
+	self.target = null;
+	self.isAlive = true;
+	self.targetX = 0;
+	self.targetY = 0;
+	self.isMoving = true;
+	var unitGraphics = self.attachAsset('knight_card', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	unitGraphics.scaleX = 0.3;
+	unitGraphics.scaleY = 0.3;
+	var healthBar = self.attachAsset('elixirBarBg', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	healthBar.scaleX = 0.3;
+	healthBar.scaleY = 0.15;
+	healthBar.y = -40;
+	var healthFill = self.attachAsset('elixirBar', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	healthFill.scaleX = 0.3;
+	healthFill.scaleY = 0.15;
+	healthFill.y = -40;
+	self.setUnitType = function (unitType, team) {
+		self.unitType = unitType;
+		self.team = team;
+		self.removeChild(unitGraphics);
+		// Get unit stats from card database
+		var cardData = cardDatabase[unitType];
+		if (cardData) {
+			self.maxHealth = 80 + cardData.baseCost * 20;
+			self.currentHealth = self.maxHealth;
+			self.damage = 15 + cardData.baseCost * 5;
+			// Different unit types have different behaviors
+			switch (unitType) {
+				case 'knight':
+					self.speed = 1.5;
+					self.range = 60;
+					break;
+				case 'archer':
+					self.speed = 2;
+					self.range = 200;
+					break;
+				case 'giant':
+					self.speed = 1;
+					self.range = 60;
+					self.maxHealth = 300;
+					self.currentHealth = 300;
+					break;
+				case 'wizard':
+					self.speed = 1.8;
+					self.range = 180;
+					self.damage = 40;
+					break;
+				default:
+					self.speed = 1.5;
+					self.range = 80;
+			}
+		}
+		unitGraphics = self.attachAsset(unitType + '_card', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+		unitGraphics.scaleX = 0.3;
+		unitGraphics.scaleY = 0.3;
+		// Set team color
+		if (team === 'enemy') {
+			unitGraphics.tint = 0xff6666;
+		} else {
+			unitGraphics.tint = 0x6666ff;
+		}
+		// Set initial target based on team
+		if (team === 'player') {
+			// Player units target enemy towers
+			if (enemyLeftTower && enemyLeftTower.currentHealth > 0) {
+				self.targetX = enemyLeftTower.x;
+				self.targetY = enemyLeftTower.y;
+			} else if (enemyRightTower && enemyRightTower.currentHealth > 0) {
+				self.targetX = enemyRightTower.x;
+				self.targetY = enemyRightTower.y;
+			} else if (enemyCentralTower && enemyCentralTower.currentHealth > 0) {
+				self.targetX = enemyCentralTower.x;
+				self.targetY = enemyCentralTower.y;
+			}
+		} else {
+			// Enemy units target player towers
+			if (playerLeftTower && playerLeftTower.currentHealth > 0) {
+				self.targetX = playerLeftTower.x;
+				self.targetY = playerLeftTower.y;
+			} else if (playerRightTower && playerRightTower.currentHealth > 0) {
+				self.targetX = playerRightTower.x;
+				self.targetY = playerRightTower.y;
+			} else if (playerCentralTower && playerCentralTower.currentHealth > 0) {
+				self.targetX = playerCentralTower.x;
+				self.targetY = playerCentralTower.y;
+			}
+		}
+	};
+	self.takeDamage = function (damage) {
+		if (self.isAlive) {
+			self.currentHealth -= damage;
+			// Flash red when taking damage
+			tween(unitGraphics, {
+				tint: 0xff0000
+			}, {
+				duration: 200,
+				onFinish: function onFinish() {
+					unitGraphics.tint = self.team === 'enemy' ? 0xff6666 : 0x6666ff;
+				}
+			});
+			if (self.currentHealth <= 0) {
+				self.isAlive = false;
+				self.destroy();
+				return true;
+			}
+		}
+		return false;
+	};
+	self.findNearestTarget = function () {
+		var nearestDistance = 999999;
+		var nearestTarget = null;
+		// Find nearest enemy unit
+		if (allUnits) {
+			for (var i = 0; i < allUnits.length; i++) {
+				var unit = allUnits[i];
+				if (unit && unit.isAlive && unit.team !== self.team) {
+					var distance = Math.sqrt(Math.pow(unit.x - self.x, 2) + Math.pow(unit.y - self.y, 2));
+					if (distance < nearestDistance && distance <= self.range * 2) {
+						nearestDistance = distance;
+						nearestTarget = unit;
+					}
+				}
+			}
+		}
+		// If no units in range, target towers
+		if (!nearestTarget) {
+			if (self.team === 'player') {
+				if (enemyLeftTower && enemyLeftTower.currentHealth > 0) {
+					var distToLeft = Math.sqrt(Math.pow(enemyLeftTower.x - self.x, 2) + Math.pow(enemyLeftTower.y - self.y, 2));
+					if (distToLeft < nearestDistance) {
+						nearestDistance = distToLeft;
+						nearestTarget = enemyLeftTower;
+					}
+				}
+				if (enemyRightTower && enemyRightTower.currentHealth > 0) {
+					var distToRight = Math.sqrt(Math.pow(enemyRightTower.x - self.x, 2) + Math.pow(enemyRightTower.y - self.y, 2));
+					if (distToRight < nearestDistance) {
+						nearestDistance = distToRight;
+						nearestTarget = enemyRightTower;
+					}
+				}
+				if (enemyCentralTower && enemyCentralTower.currentHealth > 0 && enemyCentralTower.isActive) {
+					var distToCentral = Math.sqrt(Math.pow(enemyCentralTower.x - self.x, 2) + Math.pow(enemyCentralTower.y - self.y, 2));
+					if (distToCentral < nearestDistance) {
+						nearestTarget = enemyCentralTower;
+					}
+				}
+			} else {
+				if (playerLeftTower && playerLeftTower.currentHealth > 0) {
+					var distToLeft = Math.sqrt(Math.pow(playerLeftTower.x - self.x, 2) + Math.pow(playerLeftTower.y - self.y, 2));
+					if (distToLeft < nearestDistance) {
+						nearestDistance = distToLeft;
+						nearestTarget = playerLeftTower;
+					}
+				}
+				if (playerRightTower && playerRightTower.currentHealth > 0) {
+					var distToRight = Math.sqrt(Math.pow(playerRightTower.x - self.x, 2) + Math.pow(playerRightTower.y - self.y, 2));
+					if (distToRight < nearestDistance) {
+						nearestDistance = distToRight;
+						nearestTarget = playerRightTower;
+					}
+				}
+				if (playerCentralTower && playerCentralTower.currentHealth > 0 && playerCentralTower.isActive) {
+					var distToCentral = Math.sqrt(Math.pow(playerCentralTower.x - self.x, 2) + Math.pow(playerCentralTower.y - self.y, 2));
+					if (distToCentral < nearestDistance) {
+						nearestTarget = playerCentralTower;
+					}
+				}
+			}
+		}
+		return nearestTarget;
+	};
+	self.update = function () {
+		if (!self.isAlive) return;
+		// Update health bar
+		var healthPercent = self.currentHealth / self.maxHealth;
+		healthFill.scaleX = 0.3 * healthPercent;
+		// Find target
+		self.target = self.findNearestTarget();
+		if (self.target) {
+			var distance = Math.sqrt(Math.pow(self.target.x - self.x, 2) + Math.pow(self.target.y - self.y, 2));
+			if (distance <= self.range) {
+				// Attack target
+				self.isMoving = false;
+				if (LK.ticks - self.lastAttack >= self.attackCooldown) {
+					self.target.takeDamage(self.damage);
+					self.lastAttack = LK.ticks;
+					// Attack animation
+					tween(self, {
+						scaleX: 1.2,
+						scaleY: 1.2
+					}, {
+						duration: 100,
+						onFinish: function onFinish() {
+							tween(self, {
+								scaleX: 1,
+								scaleY: 1
+							}, {
+								duration: 100
+							});
+						}
+					});
+				}
+			} else {
+				// Move towards target
+				self.isMoving = true;
+				self.targetX = self.target.x;
+				self.targetY = self.target.y;
+			}
+		}
+		// Movement
+		if (self.isMoving && self.target) {
+			var dx = self.targetX - self.x;
+			var dy = self.targetY - self.y;
+			var distance = Math.sqrt(dx * dx + dy * dy);
+			if (distance > 5) {
+				self.x += dx / distance * self.speed;
+				self.y += dy / distance * self.speed;
+			}
+		}
+	};
+	return self;
+});
 
 /**** 
 * Initialize Game
 ****/ 
@@ -223,13 +527,13 @@
 
 /**** 
 * Game Code
 ****/ 
-// Card Graphics - Legendary Cards (Orange)
-// Card Graphics - Epic Cards (Purple)
-// Card Graphics - Special Cards (Green)
-// Card Graphics - Common Cards (Gray)
 // Game states
+// Card Graphics - Common Cards (Gray)
+// Card Graphics - Special Cards (Green)
+// Card Graphics - Epic Cards (Purple)
+// Card Graphics - Legendary Cards (Orange)
 var gameState = 'main'; // 'main', 'deck', 'battle', 'shop'
 var selectedCard = null;
 var currentElixir = 5.0;
 var maxElixir = 10.0;
@@ -248,8 +552,13 @@
 var enemyCentralTower = null;
 var deploymentZones = [];
 var selectedHandCard = null;
 var isDeploymentMode = false;
+// Unit management
+var allUnits = [];
+var enemyElixir = 5.0;
+var lastEnemyDeploy = 0;
+var enemyDeckCards = ['knight', 'archer', 'giant', 'wizard', 'goblin', 'barbarian', 'minion', 'fireball'];
 // Arena data
 var arenas = [{
 	name: 'Training Camp',
 	trophiesRequired: 0,
@@ -1199,8 +1508,30 @@
 		// Flash the card
 		LK.effects.flashObject(card, 0xffffff, 300);
 		// Create deployment effect
 		LK.effects.flashScreen(0x00ff00, 200);
+		// Create actual unit
+		var unit = new Unit();
+		unit.setUnitType(card.cardId, 'player');
+		unit.x = deployX;
+		unit.y = deployY;
+		allUnits.push(unit);
+		game.addChild(unit);
+		// Unit deploy effect
+		LK.getSound('unitDeploy').play();
+		tween(unit, {
+			scaleX: 0,
+			scaleY: 0
+		}, {
+			duration: 0
+		});
+		tween(unit, {
+			scaleX: 1,
+			scaleY: 1
+		}, {
+			duration: 300,
+			easing: tween.bounceOut
+		});
 		// Rotate hand (simple simulation)
 		var nextCardIndex = Math.floor(Math.random() * currentDeck.filter(function (c) {
 			return c !== '';
 		}).length);
@@ -1245,8 +1576,58 @@
 		}
 	}
 	return false;
 }
+function deployEnemyCard(cardId, deployX, deployY) {
+	if (enemyElixir >= cardDatabase[cardId].baseCost) {
+		enemyElixir -= cardDatabase[cardId].baseCost;
+		// Create enemy unit
+		var unit = new Unit();
+		unit.setUnitType(cardId, 'enemy');
+		unit.x = deployX;
+		unit.y = deployY;
+		allUnits.push(unit);
+		game.addChild(unit);
+		// Enemy deployment effect
+		LK.effects.flashScreen(0xff4444, 200);
+	}
+}
+function enemyAI() {
+	// Enemy deploys cards every 3-8 seconds based on pressure
+	if (LK.ticks - lastEnemyDeploy > 180 + Math.random() * 300) {
+		if (enemyElixir >= 3) {
+			// Choose deployment strategy
+			var playerUnitsNearTower = 0;
+			for (var i = 0; i < allUnits.length; i++) {
+				if (allUnits[i] && allUnits[i].team === 'player' && allUnits[i].y < 1200) {
+					playerUnitsNearTower++;
+				}
+			}
+			var cardToPlay = '';
+			var deployX = 0;
+			var deployY = 0;
+			if (playerUnitsNearTower > 2) {
+				// Defensive play - deploy area defense units
+				cardToPlay = enemyDeckCards[Math.floor(Math.random() * 4)]; // Prefer cheaper units
+				deployX = 500 + Math.random() * 1000;
+				deployY = 800 + Math.random() * 200;
+			} else {
+				// Offensive play - deploy near bridges to attack
+				cardToPlay = enemyDeckCards[Math.floor(Math.random() * enemyDeckCards.length)];
+				if (Math.random() < 0.5) {
+					deployX = 700; // Left bridge
+				} else {
+					deployX = 1348; // Right bridge
+				}
+				deployY = 1000 + Math.random() * 100;
+			}
+			if (cardDatabase[cardToPlay]) {
+				deployEnemyCard(cardToPlay, deployX, deployY);
+				lastEnemyDeploy = LK.ticks;
+			}
+		}
+	}
+}
 // Add game click handler for deployment
 game.down = function (x, y, obj) {
 	if (gameState === 'battle' && isDeploymentMode && selectedHandCard) {
 		if (checkValidDeployment(x, y)) {
@@ -1296,13 +1677,24 @@
 			// 1 second at 60 FPS
 			if (currentElixir < maxElixir) {
 				currentElixir = Math.min(currentElixir + elixirRegenRate, maxElixir);
 			}
+			if (enemyElixir < maxElixir) {
+				enemyElixir = Math.min(enemyElixir + elixirRegenRate, maxElixir);
+			}
 			lastElixirUpdate = LK.ticks;
 		}
 		// Update elixir bar visual
 		var elixirPercent = currentElixir / maxElixir;
 		elixirBar.scaleX = elixirPercent;
+		// Clean up destroyed units
+		for (var i = allUnits.length - 1; i >= 0; i--) {
+			if (!allUnits[i] || !allUnits[i].isAlive) {
+				allUnits.splice(i, 1);
+			}
+		}
+		// Enemy AI
+		enemyAI();
 		// Check tower destruction and activate central towers
 		if (playerLeftTower && playerLeftTower.currentHealth <= 0 && playerCentralTower && !playerCentralTower.isActive) {
 			playerCentralTower.activate();
 		}
@@ -1314,21 +1706,23 @@
 		}
 		if (enemyRightTower && enemyRightTower.currentHealth <= 0 && enemyCentralTower && !enemyCentralTower.isActive) {
 			enemyCentralTower.activate();
 		}
-	}
-	// Simple battle simulation - award trophies randomly and damage towers
-	if (gameState === 'battle' && LK.ticks % 600 === 0) {
-		// Every 10 seconds
-		var trophyGain = Math.floor(Math.random() * 30) + 10;
-		storage.trophies += trophyGain;
-		var coinGain = Math.floor(Math.random() * 50) + 25;
-		storage.purpleCoins += coinGain;
-		// Simulate random tower damage for demo
-		if (Math.random() < 0.1 && enemyLeftTower && enemyLeftTower.currentHealth > 0) {
-			enemyLeftTower.takeDamage(20);
+		// Victory/Defeat conditions
+		if (gameState === 'battle' && LK.ticks % 60 === 0) {
+			// Check every second for game end conditions
+			if (playerCentralTower && playerCentralTower.currentHealth <= 0) {
+				// Player loses
+				setTimeout(function () {
+					LK.showGameOver();
+				}, 1000);
+			} else if (enemyCentralTower && enemyCentralTower.currentHealth <= 0) {
+				// Player wins
+				storage.trophies += 30;
+				storage.purpleCoins += 100;
+				setTimeout(function () {
+					LK.showYouWin();
+				}, 1000);
+			}
 		}
-		if (Math.random() < 0.1 && enemyRightTower && enemyRightTower.currentHealth > 0) {
-			enemyRightTower.takeDamage(20);
-		}
 	}
 };
\ No newline at end of file