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

/**** 
* Classes
****/ 
var Card = Container.expand(function (type, cost) {
	var self = Container.call(this);
	self.type = type;
	self.cost = cost;
	self.selected = false;
	var cardBg = self.attachAsset('cardSlot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var unitPreview = self.addChild(LK.getAsset(type, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8,
		y: -30
	}));
	var costText = self.addChild(new Text2(cost.toString(), {
		size: 40,
		fill: 0xFFFFFF
	}));
	costText.anchor.set(0.5, 0.5);
	costText.y = 80;
	// Add health based on unit type
	var healthValue = getCardHealth(type);
	var healthText = self.addChild(new Text2(healthValue.toString(), {
		size: 30,
		fill: 0xFF0000
	}));
	healthText.anchor.set(0.5, 0.5);
	healthText.y = 110;
	self.down = function (x, y, obj) {
		if (deckBuilder && deckBuilder.isOpen) {
			deckBuilder.selectCard(self.type);
			return;
		}
		if (selectedCard === self) {
			// Deselect if clicking the same card again
			selectedCard = null;
			self.selected = false;
			cardBg.tint = 0xFFFFFF;
			targetingCircle.visible = false;
		} else if (currentEnergy >= self.cost && !selectedCard) {
			selectedCard = self;
			self.selected = true;
			cardBg.tint = 0x00FF00;
			// Add glow effect for selected card
			LK.effects.flashObject(cardBg, 0xFFFF00, 200);
		} else if (currentEnergy < self.cost) {
			// Visual feedback for insufficient energy
			cardBg.tint = 0xFF0000;
			LK.setTimeout(function () {
				cardBg.tint = 0xFFFFFF;
			}, 500);
		}
	};
	return self;
});
var DeckBuilder = Container.expand(function () {
	var self = Container.call(this);
	self.isOpen = false;
	self.selectedDeck = [];
	self.availableCards = allCardTypes.slice();
	var bg = self.attachAsset('arena', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.6
	});
	bg.tint = 0x222222;
	var titleText = self.addChild(new Text2("Tüm Kartlar - 4 Seç", {
		size: 60,
		fill: 0xFFFFFF
	}));
	titleText.anchor.set(0.5, 0.5);
	titleText.y = -300;
	self.show = function () {
		self.isOpen = true;
		self.visible = true;
		self.selectedDeck = [];
		titleText.setText("Tüm Kartlar - 4 Seç");
		self.refreshCards();
	};
	self.hide = function () {
		self.isOpen = false;
		self.visible = false;
	};
	self.refreshCards = function () {
		for (var i = self.children.length - 1; i >= 0; i--) {
			if (self.children[i].isCardOption) {
				self.children[i].destroy();
			}
		}
		// Show all 15 cards in a 5x3 grid layout
		for (var i = 0; i < self.availableCards.length; i++) {
			var cardType = self.availableCards[i];
			var cost = allCardCosts[allCardTypes.indexOf(cardType)];
			var cardOption = self.addChild(new Card(cardType, cost));
			cardOption.isCardOption = true;
			cardOption.x = -400 + i % 5 * 200;
			cardOption.y = -200 + Math.floor(i / 5) * 300;
			cardOption.scaleX = 0.6;
			cardOption.scaleY = 0.6;
			// Highlight already selected cards
			for (var j = 0; j < self.selectedDeck.length; j++) {
				if (self.selectedDeck[j] === cardType) {
					cardOption.children[0].tint = 0x00FF00;
					break;
				}
			}
		}
	};
	self.selectCard = function (cardType) {
		if (self.selectedDeck.length < 4) {
			self.selectedDeck.push(cardType);
			// Update title to show progress
			titleText.setText("Seçilen: " + self.selectedDeck.length + "/4");
			if (self.selectedDeck.length === 4) {
				playerDeck = self.selectedDeck.slice();
				self.hide();
				setupPlayerCards();
			}
		}
	};
	self.visible = false;
	return self;
});
var Projectile = Container.expand(function (startX, startY, target, damage) {
	var self = Container.call(this);
	self.x = startX;
	self.y = startY;
	self.target = target;
	self.damage = damage;
	self.speed = 8;
	var projectileGraphics = self.attachAsset('projectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		if (!self.target || self.target.health <= 0) {
			self.destroy();
			return;
		}
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.target.height / 2 - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 30) {
			// Hit target
			self.target.takeDamage(self.damage);
			self.destroy();
		} else {
			// Move toward target
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	return self;
});
var Tower = Container.expand(function (isPlayer, isKing) {
	var self = Container.call(this);
	self.isPlayer = isPlayer;
	self.isKing = isKing;
	self.maxHealth = isKing ? 3000 : 2000;
	self.health = self.maxHealth;
	self.attackDamage = isKing ? 200 : 150;
	self.attackRange = 250;
	self.attackCooldown = 0;
	self.attackSpeed = 60; // frames between attacks
	var assetName = (isPlayer ? 'player' : 'enemy') + (isKing ? 'KingTower' : 'Tower');
	var towerGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 1.0
	});
	// Health bar
	var healthBarBg = self.addChild(LK.getAsset('energyBar', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.4,
		scaleY: 0.3,
		y: -200
	}));
	healthBarBg.tint = 0x333333;
	var healthBar = self.addChild(LK.getAsset('energyBar', {
		anchorX: 0,
		anchorY: 0.5,
		scaleX: 0.4,
		scaleY: 0.3,
		y: -200,
		x: -60
	}));
	healthBar.tint = isPlayer ? 0x00FF00 : 0xFF0000;
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health < 0) self.health = 0;
		var healthPercent = self.health / self.maxHealth;
		healthBar.scaleX = 0.4 * healthPercent;
		// Flash effect
		LK.effects.flashObject(towerGraphics, 0xFF0000, 300);
		LK.getSound('towerHit').play();
		if (self.health <= 0) {
			self.destroy();
			if (isKing) {
				if (isPlayer) {
					LK.showGameOver();
				} else {
					LK.showYouWin();
				}
			}
		}
	};
	self.update = function () {
		if (self.attackCooldown > 0) {
			self.attackCooldown--;
			return;
		}
		// Find closest enemy unit
		var targetUnits = self.isPlayer ? enemyUnits : playerUnits;
		var closestUnit = null;
		var closestDistance = Infinity;
		for (var i = 0; i < targetUnits.length; i++) {
			var unit = targetUnits[i];
			var dx = unit.x - self.x;
			var dy = unit.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < self.attackRange && distance < closestDistance) {
				closestDistance = distance;
				closestUnit = unit;
			}
		}
		if (closestUnit) {
			self.attackCooldown = self.attackSpeed;
			// Create projectile
			var projectile = new Projectile(self.x, self.y - 50, closestUnit, self.attackDamage);
			game.addChild(projectile);
			projectiles.push(projectile);
		}
	};
	return self;
});
var Unit = Container.expand(function (type, isPlayer) {
	var self = Container.call(this);
	self.isPlayer = isPlayer;
	self.type = type;
	self.moveSpeed = 2;
	self.attackDamage = 100;
	self.attackRange = 80;
	self.attackCooldown = 0;
	self.attackSpeed = 60;
	self.target = null;
	// Set stats based on type
	switch (type) {
		case 'soldier':
			self.maxHealth = 400;
			self.moveSpeed = 2;
			self.attackDamage = 80;
			break;
		case 'archer':
			self.maxHealth = 200;
			self.moveSpeed = 2.5;
			self.attackDamage = 60;
			self.attackRange = 150;
			break;
		case 'tank':
			self.maxHealth = 800;
			self.moveSpeed = 1;
			self.attackDamage = 120;
			break;
		case 'wizard':
			self.maxHealth = 300;
			self.moveSpeed = 2;
			self.attackDamage = 150;
			self.attackRange = 180;
			break;
		case 'dragon':
			self.maxHealth = 1200;
			self.moveSpeed = 1.5;
			self.attackDamage = 200;
			self.attackRange = 200;
			break;
		case 'knight':
			self.maxHealth = 600;
			self.moveSpeed = 1.8;
			self.attackDamage = 100;
			break;
		case 'goblin':
			self.maxHealth = 150;
			self.moveSpeed = 3;
			self.attackDamage = 50;
			break;
		case 'giant':
			self.maxHealth = 1500;
			self.moveSpeed = 0.8;
			self.attackDamage = 250;
			break;
		case 'healer':
			self.maxHealth = 250;
			self.moveSpeed = 2;
			self.attackDamage = 20;
			self.attackRange = 160;
			break;
		case 'assassin':
			self.maxHealth = 180;
			self.moveSpeed = 3.5;
			self.attackDamage = 120;
			break;
		case 'bomber':
			self.maxHealth = 220;
			self.moveSpeed = 2.2;
			self.attackDamage = 180;
			self.attackRange = 140;
			break;
		case 'mage':
			self.maxHealth = 280;
			self.moveSpeed = 2.1;
			self.attackDamage = 160;
			self.attackRange = 190;
			break;
		case 'berserker':
			self.maxHealth = 500;
			self.moveSpeed = 2.3;
			self.attackDamage = 140;
			break;
		case 'paladin':
			self.maxHealth = 700;
			self.moveSpeed = 1.6;
			self.attackDamage = 110;
			break;
	}
	self.health = self.maxHealth;
	var unitGraphics = self.attachAsset(type, {
		anchorX: 0.5,
		anchorY: 1.0
	});
	if (!isPlayer) {
		unitGraphics.scaleX = -1; // Flip enemy units
	}
	// Health bar for unit
	var healthBarBg = self.addChild(LK.getAsset('energyBar', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.2,
		scaleY: 0.2,
		y: -self.maxHealth / 10 - 20
	}));
	healthBarBg.tint = 0x333333;
	var healthBar = self.addChild(LK.getAsset('energyBar', {
		anchorX: 0,
		anchorY: 0.5,
		scaleX: 0.2,
		scaleY: 0.2,
		y: -self.maxHealth / 10 - 20,
		x: -30
	}));
	healthBar.tint = isPlayer ? 0x00FF00 : 0xFF0000;
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health < 0) self.health = 0;
		var healthPercent = self.health / self.maxHealth;
		healthBar.scaleX = 0.2 * healthPercent;
		if (self.health <= 0) {
			LK.effects.flashObject(unitGraphics, 0xFF0000, 200);
			LK.getSound('unitDeath').play();
			self.destroy();
		} else {
			LK.effects.flashObject(unitGraphics, 0xFF0000, 150);
		}
	};
	self.findTarget = function () {
		var targetUnits = self.isPlayer ? enemyUnits : playerUnits;
		var targetTowers = self.isPlayer ? enemyTowers : playerTowers;
		var allTargets = targetUnits.concat(targetTowers);
		var closest = null;
		var closestDistance = Infinity;
		for (var i = 0; i < allTargets.length; i++) {
			var target = allTargets[i];
			if (!target || target.health <= 0) continue;
			var dx = target.x - self.x;
			var dy = target.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < closestDistance) {
				closestDistance = distance;
				closest = target;
			}
		}
		return closest;
	};
	self.update = function () {
		if (!self.target || self.target.health <= 0) {
			self.target = self.findTarget();
		}
		if (!self.target) return;
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance <= self.attackRange) {
			// Attack
			if (self.attackCooldown <= 0) {
				self.attackCooldown = self.attackSpeed;
				// Create attack effects
				LK.effects.flashObject(self, 0xFFFF00, 200);
				if (self.type === 'archer' || self.type === 'wizard' || self.type === 'dragon' || self.type === 'healer' || self.type === 'bomber' || self.type === 'mage') {
					// Ranged attack with projectile
					var projectile = new Projectile(self.x, self.y - 40, self.target, self.attackDamage);
					game.addChild(projectile);
					projectiles.push(projectile);
				} else {
					// Melee attack with effects
					if (self.type === 'bomber') {
						// Bomber creates explosion effect
						LK.effects.flashObject(self.target, 0xFF4500, 400);
						LK.getSound('explosion').play();
					} else if (self.type === 'berserker') {
						// Berserker gets damage boost when low health
						var damageBonus = self.health < self.maxHealth * 0.3 ? 50 : 0;
						self.target.takeDamage(self.attackDamage + damageBonus);
						LK.effects.flashObject(self, 0xDC143C, 300);
					} else {
						self.target.takeDamage(self.attackDamage);
					}
				}
			}
		} else {
			// Move toward target
			var moveX = dx / distance * self.moveSpeed;
			var moveY = dy / distance * self.moveSpeed;
			self.x += moveX;
			self.y += moveY;
		}
		if (self.attackCooldown > 0) {
			self.attackCooldown--;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var currentEnergy = 10;
var maxEnergy = 10;
var energyRegenRate = 1; // energy per second
var energyRegenTimer = 0;
var playerUnits = [];
var enemyUnits = [];
var playerTowers = [];
var enemyTowers = [];
var projectiles = [];
var playerCards = [];
var selectedCard = null;
var playerCups = storage.playerCups || 100; // Starting cups
var matchInProgress = false;
// Override LK's game over and win functions to handle cup system
LK.showGameOver = function () {
	playerCups -= 5;
	if (playerCups < 0) playerCups = 0;
	storage.playerCups = playerCups;
	matchInProgress = false;
	// Reset game state
	game.destroy();
	// Restart the game
	location.reload();
};
LK.showYouWin = function () {
	playerCups += 30;
	storage.playerCups = playerCups;
	matchInProgress = false;
	// Reset game state
	game.destroy();
	// Restart the game
	location.reload();
};
// Arena setup
var arena = game.addChild(LK.getAsset('arena', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 1366
}));
// Add red centerline
var centerLine = game.addChild(LK.getAsset('centerLine', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 1366
}));
// River removed
// Bridges removed
// Create towers
// Player towers (bottom)
var playerKingTower = new Tower(true, true);
playerKingTower.x = 1024;
playerKingTower.y = 2200;
game.addChild(playerKingTower);
playerTowers.push(playerKingTower);
var playerLeftTower = new Tower(true, false);
playerLeftTower.x = 600;
playerLeftTower.y = 2000;
game.addChild(playerLeftTower);
playerTowers.push(playerLeftTower);
var playerRightTower = new Tower(true, false);
playerRightTower.x = 1448;
playerRightTower.y = 2000;
game.addChild(playerRightTower);
playerTowers.push(playerRightTower);
// Enemy towers (top)
var enemyKingTower = new Tower(false, true);
enemyKingTower.x = 1024;
enemyKingTower.y = 600;
game.addChild(enemyKingTower);
enemyTowers.push(enemyKingTower);
var enemyLeftTower = new Tower(false, false);
enemyLeftTower.x = 600;
enemyLeftTower.y = 800;
game.addChild(enemyLeftTower);
enemyTowers.push(enemyLeftTower);
var enemyRightTower = new Tower(false, false);
enemyRightTower.x = 1448;
enemyRightTower.y = 800;
game.addChild(enemyRightTower);
enemyTowers.push(enemyRightTower);
// UI Setup
var energyBarBg = LK.gui.bottom.addChild(LK.getAsset('energyBar', {
	anchorX: 0.5,
	anchorY: 1.0,
	y: -350,
	scaleX: 1.2,
	scaleY: 0.8
}));
energyBarBg.tint = 0x333333;
var energyBar = LK.gui.bottom.addChild(LK.getAsset('energyBar', {
	anchorX: 0,
	anchorY: 1.0,
	y: -350,
	x: -180,
	scaleX: 1.2,
	scaleY: 0.8
}));
var energyText = LK.gui.bottom.addChild(new Text2("10/10", {
	size: 40,
	fill: 0xFFFFFF
}));
energyText.anchor.set(0.5, 1.0);
energyText.y = -320;
// All available card types (15 total)
var allCardTypes = ['soldier', 'archer', 'tank', 'wizard', 'dragon', 'knight', 'goblin', 'giant', 'healer', 'assassin', 'bomber', 'mage', 'berserker', 'paladin', 'fireball'];
var allCardCosts = [2, 3, 4, 5, 8, 3, 1, 6, 4, 2, 4, 5, 4, 5, 3];
var playerDeck = ['soldier', 'archer', 'tank', 'wizard']; // Default deck 
function getCardHealth(type) {
	switch (type) {
		case 'soldier':
			return 400;
		case 'archer':
			return 200;
		case 'tank':
			return 800;
		case 'wizard':
			return 300;
		case 'dragon':
			return 1200;
		case 'knight':
			return 600;
		case 'goblin':
			return 150;
		case 'giant':
			return 1500;
		case 'healer':
			return 250;
		case 'assassin':
			return 180;
		case 'bomber':
			return 220;
		case 'mage':
			return 280;
		case 'berserker':
			return 500;
		case 'paladin':
			return 700;
		case 'fireball':
			return 100;
		default:
			return 100;
	}
}
function setupPlayerCards() {
	// Clear existing cards 
	for (var i = 0; i < playerCards.length; i++) {
		playerCards[i].destroy();
	}
	playerCards = [];
	// Create cards from player deck - centered on screen
	var cardWidth = 220;
	var totalWidth = 4 * cardWidth;
	var startX = -(totalWidth / 2) + cardWidth / 2;
	for (var i = 0; i < 4; i++) {
		var cardType = playerDeck[i];
		var cost = allCardCosts[allCardTypes.indexOf(cardType)];
		var card = new Card(cardType, cost);
		card.x = startX + i * cardWidth;
		card.y = -80;
		LK.gui.bottom.addChild(card);
		playerCards.push(card);
	}
}
// Create main menu
var mainMenu = new Container();
mainMenu.x = 0;
mainMenu.y = 0;
LK.gui.center.addChild(mainMenu);
var menuBg = mainMenu.addChild(LK.getAsset('arena', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 1.0,
	scaleY: 1.0
}));
menuBg.tint = 0x1a1a2e;
var titleText = mainMenu.addChild(new Text2("Tower Defense Arena", {
	size: 80,
	fill: 0xFFFFFF
}));
titleText.anchor.set(0.5, 0.5);
titleText.y = -400;
var myCardsBtn = mainMenu.addChild(LK.getAsset('cardSlot', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: -200,
	y: -250,
	scaleX: 0.8,
	scaleY: 0.8
}));
var myCardsText = mainMenu.addChild(new Text2("Kartlarım", {
	size: 40,
	fill: 0xFFFFFF
}));
myCardsText.anchor.set(0.5, 0.5);
myCardsText.x = -200;
myCardsText.y = -250;
var vsBtn = mainMenu.addChild(LK.getAsset('cardSlot', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 0,
	y: -250,
	scaleX: 0.8,
	scaleY: 0.8
}));
var vsText = mainMenu.addChild(new Text2("İki Kişilik", {
	size: 40,
	fill: 0xFFFFFF
}));
vsText.anchor.set(0.5, 0.5);
vsText.x = 0;
vsText.y = -250;
var shopBtn = mainMenu.addChild(LK.getAsset('cardSlot', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 200,
	y: -250,
	scaleX: 0.8,
	scaleY: 0.8
}));
var shopText = mainMenu.addChild(new Text2("Mağaza", {
	size: 40,
	fill: 0xFFFFFF
}));
shopText.anchor.set(0.5, 0.5);
shopText.x = 200;
shopText.y = -250;
// Add Enter Match button
var enterMatchBtn = mainMenu.addChild(LK.getAsset('cardSlot', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 0,
	y: -50,
	scaleX: 1.2,
	scaleY: 0.8
}));
enterMatchBtn.tint = 0x00AA00;
var enterMatchText = mainMenu.addChild(new Text2("Maça Girme", {
	size: 50,
	fill: 0xFFFFFF
}));
enterMatchText.anchor.set(0.5, 0.5);
enterMatchText.x = 0;
enterMatchText.y = -50;
var cupBtn = mainMenu.addChild(LK.getAsset('cardSlot', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 0,
	y: 150,
	scaleX: 0.8,
	scaleY: 0.8
}));
var cupText = mainMenu.addChild(new Text2("Kupa", {
	size: 40,
	fill: 0xFFFFFF
}));
cupText.anchor.set(0.5, 0.5);
cupText.x = 0;
cupText.y = 150;
// Add cup counter display
var cupCountText = mainMenu.addChild(new Text2("Kupalar: " + playerCups, {
	size: 50,
	fill: 0xFFD700
}));
cupCountText.anchor.set(0.5, 0.5);
cupCountText.x = 0;
cupCountText.y = 300;
// Update cup display function
function updateCupDisplay() {
	cupCountText.setText("Kupalar: " + playerCups);
}
// Button interactions using LK event system
enterMatchBtn.down = function () {
	mainMenu.visible = false;
	matchInProgress = true;
};
myCardsBtn.down = function () {
	deckBuilder.show();
};
vsBtn.down = function () {
	mainMenu.visible = false;
};
shopBtn.down = function () {
	// Shop functionality to be added
};
cupBtn.down = function () {
	// Cup/Trophy functionality to be added
};
// Create deck builder
var deckBuilder = new DeckBuilder();
deckBuilder.x = 0;
deckBuilder.y = 0;
LK.gui.center.addChild(deckBuilder);
// Show main menu at start
mainMenu.visible = true;
// Setup initial cards
setupPlayerCards();
// Add deployment area indicator
var deploymentArea = game.addChild(LK.getAsset('centerLine', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 1783,
	scaleY: 0.5
}));
deploymentArea.tint = 0x00FF00;
deploymentArea.alpha = 0.3;
// Add fireball restricted area indicator
var fireballArea = game.addChild(LK.getAsset('centerLine', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 1683,
	scaleX: 0.7,
	scaleY: 0.3
}));
fireballArea.tint = 0xFF4500;
fireballArea.alpha = 0.2;
// Add white targeting circle for fireball (initially hidden)
var targetingCircle = game.addChild(LK.getAsset('centerCircle', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 2.4,
	scaleY: 2.4
}));
targetingCircle.tint = 0xFFFFFF;
targetingCircle.alpha = 0.5;
targetingCircle.visible = false;
// Simple AI for enemy
var aiTimer = 0;
var aiDeployInterval = 180; // Deploy every 3 seconds
var enemyEnergy = 10;
var enemyMaxEnergy = 10;
var enemyEnergyRegenTimer = 0;
function updateEnergy() {
	// Don't update energy when deck builder is open or match is not in progress
	if (deckBuilder.isOpen || !matchInProgress) {
		return;
	}
	energyRegenTimer++;
	if (energyRegenTimer >= 60) {
		// 1 second at 60 FPS
		energyRegenTimer = 0;
		if (currentEnergy < maxEnergy) {
			currentEnergy++;
			var energyPercent = currentEnergy / maxEnergy;
			energyBar.scaleX = 1.2 * energyPercent;
			energyText.setText(currentEnergy + "/" + maxEnergy);
		}
	}
}
function updateAI() {
	// Don't update AI when deck builder is open or match is not in progress
	if (deckBuilder.isOpen || !matchInProgress) {
		return;
	}
	// Update enemy energy
	enemyEnergyRegenTimer++;
	if (enemyEnergyRegenTimer >= 60) {
		enemyEnergyRegenTimer = 0;
		if (enemyEnergy < enemyMaxEnergy) {
			enemyEnergy++;
		}
	}
	aiTimer++;
	if (aiTimer >= aiDeployInterval) {
		aiTimer = 0;
		// Simple AI: deploy random unit or fireball
		var actionType = Math.random();
		if (actionType < 0.3 && enemyEnergy >= 3) {
			// Deploy fireball - enemy can only target player area (below centerline)
			var fireballX = 600 + Math.random() * 800;
			var fireballY = 1500 + Math.random() * 500; // Only in player area
			// Create fireball effect
			var fireballEffect = game.addChild(LK.getAsset('fireball', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: fireballX,
				y: fireballY
			}));
			// Create explosion damage area
			var explosionRadius = 120;
			var explosionDamage = 200;
			// Damage all player units in radius
			for (var i = 0; i < playerUnits.length; i++) {
				var unit = playerUnits[i];
				if (unit && unit.health > 0) {
					var dx = unit.x - fireballX;
					var dy = unit.y - fireballY;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < explosionRadius) {
						unit.takeDamage(explosionDamage);
					}
				}
			}
			// Damage player towers in radius
			for (var i = 0; i < playerTowers.length; i++) {
				var tower = playerTowers[i];
				if (tower && tower.health > 0) {
					var dx = tower.x - fireballX;
					var dy = tower.y - fireballY;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < explosionRadius) {
						tower.takeDamage(explosionDamage);
					}
				}
			}
			// Visual effects
			LK.effects.flashScreen(0xFF4500, 300);
			LK.getSound('explosion').play();
			// Remove fireball effect after 1 second
			LK.setTimeout(function () {
				fireballEffect.destroy();
			}, 1000);
			enemyEnergy -= 3;
		} else if (enemyEnergy >= 2) {
			// Deploy regular unit - enemy units spawn in enemy area (above centerline)
			var unitType = allCardTypes[Math.floor(Math.random() * (allCardTypes.length - 1))]; // Exclude fireball
			var unitCost = allCardCosts[allCardTypes.indexOf(unitType)];
			if (enemyEnergy >= unitCost) {
				var enemyUnit = new Unit(unitType, false);
				enemyUnit.x = 800 + Math.random() * 400;
				enemyUnit.y = 900 + Math.random() * 300; // Enemy area only
				game.addChild(enemyUnit);
				enemyUnits.push(enemyUnit);
				enemyEnergy -= unitCost;
			}
		}
	}
}
game.move = function (x, y, obj) {
	if (selectedCard && selectedCard.type === 'fireball') {
		// Show targeting circle for fireball
		targetingCircle.visible = true;
		targetingCircle.x = x;
		targetingCircle.y = y;
	} else {
		targetingCircle.visible = false;
	}
};
game.down = function (x, y, obj) {
	if (selectedCard) {
		// Special handling for fireball spell
		if (selectedCard.type === 'fireball') {
			// Hide targeting circle
			targetingCircle.visible = false;
			// Fireball can only be deployed in enemy area (above centerline) by player
			if (y > 600 && y < 1366 && x > 300 && x < 1748 && currentEnergy >= selectedCard.cost) {
				// Create fireball effect
				var fireballEffect = game.addChild(LK.getAsset('fireball', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: x,
					y: y
				}));
				// Create explosion damage area
				var explosionRadius = 120;
				var explosionDamage = 200;
				// Damage all enemy units in radius
				for (var i = 0; i < enemyUnits.length; i++) {
					var unit = enemyUnits[i];
					if (unit && unit.health > 0) {
						var dx = unit.x - x;
						var dy = unit.y - y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < explosionRadius) {
							unit.takeDamage(explosionDamage);
						}
					}
				}
				// Damage enemy towers in radius
				for (var i = 0; i < enemyTowers.length; i++) {
					var tower = enemyTowers[i];
					if (tower && tower.health > 0) {
						var dx = tower.x - x;
						var dy = tower.y - y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < explosionRadius) {
							tower.takeDamage(explosionDamage);
						}
					}
				}
				// Visual effects
				LK.effects.flashScreen(0xFF4500, 500);
				LK.getSound('explosion').play();
				// Remove fireball effect after 1 second
				LK.setTimeout(function () {
					fireballEffect.destroy();
				}, 1000);
				currentEnergy -= selectedCard.cost;
				var energyPercent = currentEnergy / maxEnergy;
				energyBar.scaleX = 1.2 * energyPercent;
				energyText.setText(currentEnergy + "/" + maxEnergy);
				LK.getSound('cardPlay').play();
				// Remove card and replace
				var cardIndex = playerCards.indexOf(selectedCard);
				if (cardIndex !== -1) {
					selectedCard.destroy();
					playerCards.splice(cardIndex, 1);
					var newCardType = playerDeck[Math.floor(Math.random() * playerDeck.length)];
					var newCardCost = allCardCosts[allCardTypes.indexOf(newCardType)];
					var newCard = new Card(newCardType, newCardCost);
					var cardWidth = 220;
					var totalWidth = 4 * cardWidth;
					var startX = -(totalWidth / 2) + cardWidth / 2;
					newCard.x = startX + cardIndex * cardWidth;
					newCard.y = -80;
					LK.gui.bottom.addChild(newCard);
					playerCards.splice(cardIndex, 0, newCard);
				}
			}
			// Deselect card
			selectedCard = null;
			targetingCircle.visible = false;
		} else if (y > 1366 && y < 2200) {
			// Regular unit deployment - restrict to player's area only (below centerline)
			if (currentEnergy >= selectedCard.cost) {
				// Deploy unit
				var newUnit = new Unit(selectedCard.type, true);
				newUnit.x = x;
				newUnit.y = y;
				game.addChild(newUnit);
				playerUnits.push(newUnit);
				currentEnergy -= selectedCard.cost;
				var energyPercent = currentEnergy / maxEnergy;
				energyBar.scaleX = 1.2 * energyPercent;
				energyText.setText(currentEnergy + "/" + maxEnergy);
				LK.getSound('cardPlay').play();
				// Remove card from hand and get replacement from deck
				var cardIndex = playerCards.indexOf(selectedCard);
				if (cardIndex !== -1) {
					selectedCard.destroy();
					playerCards.splice(cardIndex, 1);
					// Add replacement card from deck with centered positioning
					var newCardType = playerDeck[Math.floor(Math.random() * playerDeck.length)];
					var newCardCost = allCardCosts[allCardTypes.indexOf(newCardType)];
					var newCard = new Card(newCardType, newCardCost);
					var cardWidth = 220;
					var totalWidth = 4 * cardWidth;
					var startX = -(totalWidth / 2) + cardWidth / 2;
					newCard.x = startX + cardIndex * cardWidth;
					newCard.y = -80;
					LK.gui.bottom.addChild(newCard);
					playerCards.splice(cardIndex, 0, newCard);
				}
			}
			// Deselect card
			selectedCard = null;
			targetingCircle.visible = false;
		} else {
			// Deselect card if clicked outside valid area
			if (selectedCard) {
				selectedCard.children[0].tint = 0xFFFFFF;
				selectedCard.selected = false;
				selectedCard = null;
			}
			targetingCircle.visible = false;
		}
	}
};
game.update = function () {
	updateEnergy();
	updateAI();
	// Clean up destroyed units
	for (var i = playerUnits.length - 1; i >= 0; i--) {
		if (playerUnits[i].health <= 0) {
			playerUnits[i].destroy();
			playerUnits.splice(i, 1);
		}
	}
	for (var i = enemyUnits.length - 1; i >= 0; i--) {
		if (enemyUnits[i].health <= 0) {
			enemyUnits[i].destroy();
			enemyUnits.splice(i, 1);
		}
	}
	for (var i = projectiles.length - 1; i >= 0; i--) {
		if (!projectiles[i].parent) {
			projectiles.splice(i, 1);
		}
	}
	// Clean up destroyed towers
	for (var i = playerTowers.length - 1; i >= 0; i--) {
		if (playerTowers[i].health <= 0 && playerTowers[i].parent) {
			playerTowers.splice(i, 1);
		}
	}
	for (var i = enemyTowers.length - 1; i >= 0; i--) {
		if (enemyTowers[i].health <= 0 && enemyTowers[i].parent) {
			enemyTowers.splice(i, 1);
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -41,9 +41,15 @@
 		if (deckBuilder && deckBuilder.isOpen) {
 			deckBuilder.selectCard(self.type);
 			return;
 		}
-		if (currentEnergy >= self.cost && !selectedCard) {
+		if (selectedCard === self) {
+			// Deselect if clicking the same card again
+			selectedCard = null;
+			self.selected = false;
+			cardBg.tint = 0xFFFFFF;
+			targetingCircle.visible = false;
+		} else if (currentEnergy >= self.cost && !selectedCard) {
 			selectedCard = self;
 			self.selected = true;
 			cardBg.tint = 0x00FF00;
 			// Add glow effect for selected card
@@ -997,11 +1003,13 @@
 			selectedCard = null;
 			targetingCircle.visible = false;
 		} else {
 			// Deselect card if clicked outside valid area
-			selectedCard.children[0].tint = 0xFFFFFF;
-			selectedCard.selected = false;
-			selectedCard = null;
+			if (selectedCard) {
+				selectedCard.children[0].tint = 0xFFFFFF;
+				selectedCard.selected = false;
+				selectedCard = null;
+			}
 			targetingCircle.visible = false;
 		}
 	}
 };