/**** 
* 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;
	// Add card name in Turkish
	var nameText = self.addChild(new Text2(getCardName(type).toUpperCase(), {
		size: 28,
		fill: 0xFFFFFF
	}));
	nameText.anchor.set(0.5, 0.5);
	nameText.y = 135;
	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 - 8 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 - 8 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;
			// Update card name text to uppercase for deck builder cards with larger font size
			if (cardOption.children.length > 3) {
				cardOption.children[3].setText(getCardName(cardType).toUpperCase());
				// Create new text with larger font size for deck builder
				var nameText = cardOption.children[3];
				nameText.destroy();
				var newNameText = cardOption.addChild(new Text2(getCardName(cardType).toUpperCase(), {
					size: 45,
					fill: 0xFFFFFF
				}));
				newNameText.anchor.set(0.5, 0.5);
				newNameText.y = 135;
			}
			// 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 < 8) {
			self.selectedDeck.push(cardType);
			// Update title to show progress
			titleText.setText("Seçilen: " + self.selectedDeck.length + "/8");
			if (self.selectedDeck.length === 8) {
				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 'freeze':
			self.maxHealth = 280;
			self.moveSpeed = 1.8;
			self.attackDamage = 80;
			self.attackRange = 150;
			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;
			break;
		case 'guardian':
			self.maxHealth = 750;
			self.moveSpeed = 1.5;
			self.attackDamage = 95;
		case 'berserker':
			self.maxHealth = 500;
			self.moveSpeed = 2.3;
			self.attackDamage = 140;
			break;
			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 === 'freeze') {
					// 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;
var matchTimer = 120 * 60; // 2 minutes in frames (60 FPS)
var matchTimerText = null;
var inOvertime = 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;
// Add match timer display
matchTimerText = LK.gui.top.addChild(new Text2("2:00", {
	size: 60,
	fill: 0xFFFFFF
}));
matchTimerText.anchor.set(0.5, 0);
matchTimerText.y = 100;
matchTimerText.visible = false;
// All available card types (15 total)
var allCardTypes = ['soldier', 'archer', 'tank', 'wizard', 'dragon', 'poison', 'goblin', 'giant', 'healer', 'assassin', 'bomber', 'freeze', 'berserker', 'guardian', 'fireball'];
var allCardCosts = [2, 3, 4, 5, 8, 3, 1, 6, 4, 2, 4, 5, 4, 5, 3];
var playerDeck = ['soldier', 'archer', 'tank', 'wizard', 'dragon', 'poison', 'goblin', 'giant']; // Default 8-card deck
function getCardName(type) {
	switch (type) {
		case 'soldier':
			return 'Asker';
		case 'archer':
			return 'Okçu';
		case 'tank':
			return 'Tank';
		case 'wizard':
			return 'Büyücü';
		case 'dragon':
			return 'Ejder';
		case 'poison':
			return 'Zehir';
		case 'freeze':
			return 'Dondurma';
		case 'guardian':
			return 'Koruyucu';
		case 'goblin':
			return 'Goblin';
		case 'giant':
			return 'Dev';
		case 'healer':
			return 'Şifacı';
		case 'assassin':
			return 'Suikastçi';
		case 'bomber':
			return 'Bombacı';
		case 'berserker':
			return 'Berserker';
		case 'fireball':
			return 'Alev Topu';
		default:
			return 'Bilinmiyen';
	}
}
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 'poison':
			return 250;
		case 'freeze':
			return 280;
		case 'guardian':
			return 750;
		case 'goblin':
			return 150;
		case 'giant':
			return 1500;
		case 'healer':
			return 250;
		case 'assassin':
			return 180;
		case 'bomber':
			return 220;
		case 'berserker':
			return 500;
		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 - ensure different cards in hand
	var cardWidth = 220;
	var totalWidth = 4 * cardWidth;
	var startX = -(totalWidth / 2) + cardWidth / 2;
	var availableTypes = playerDeck.slice(); // Copy of deck
	for (var i = 0; i < 4; i++) {
		// Randomly select from available types to ensure variety
		var randomIndex = Math.floor(Math.random() * availableTypes.length);
		var cardType = availableTypes[randomIndex];
		// Remove selected type to prevent immediate duplicates
		availableTypes.splice(randomIndex, 1);
		// If we run out of unique types, refill from deck
		if (availableTypes.length === 0) {
			availableTypes = playerDeck.slice();
		}
		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 saveBtn = mainMenu.addChild(LK.getAsset('cardSlot', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: -150,
	y: 150,
	scaleX: 0.8,
	scaleY: 0.8
}));
var saveText = mainMenu.addChild(new Text2("Kaydet", {
	size: 40,
	fill: 0xFFFFFF
}));
saveText.anchor.set(0.5, 0.5);
saveText.x = -150;
saveText.y = 150;
var loadBtn = mainMenu.addChild(LK.getAsset('cardSlot', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 150,
	y: 150,
	scaleX: 0.8,
	scaleY: 0.8
}));
var loadText = mainMenu.addChild(new Text2("Yükle", {
	size: 40,
	fill: 0xFFFFFF
}));
loadText.anchor.set(0.5, 0.5);
loadText.x = 150;
loadText.y = 150;
var cupBtn = mainMenu.addChild(LK.getAsset('cardSlot', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 0,
	y: 250,
	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 = 250;
// 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 = 400;
// Update cup display function
function updateCupDisplay() {
	cupCountText.setText("Kupalar: " + playerCups);
}
// Save game function
function saveGame() {
	if (!matchInProgress) return;
	var gameState = {
		currentEnergy: currentEnergy,
		playerCups: playerCups,
		playerDeck: playerDeck.slice(),
		playerUnitsData: [],
		enemyUnitsData: [],
		playerTowersData: [],
		enemyTowersData: []
	};
	// Save player units data
	for (var i = 0; i < playerUnits.length; i++) {
		var unit = playerUnits[i];
		gameState.playerUnitsData.push({
			type: unit.type,
			x: unit.x,
			y: unit.y,
			health: unit.health,
			attackCooldown: unit.attackCooldown
		});
	}
	// Save enemy units data
	for (var i = 0; i < enemyUnits.length; i++) {
		var unit = enemyUnits[i];
		gameState.enemyUnitsData.push({
			type: unit.type,
			x: unit.x,
			y: unit.y,
			health: unit.health,
			attackCooldown: unit.attackCooldown
		});
	}
	// Save player towers data
	for (var i = 0; i < playerTowers.length; i++) {
		var tower = playerTowers[i];
		gameState.playerTowersData.push({
			health: tower.health,
			x: tower.x,
			y: tower.y,
			isKing: tower.isKing
		});
	}
	// Save enemy towers data
	for (var i = 0; i < enemyTowers.length; i++) {
		var tower = enemyTowers[i];
		gameState.enemyTowersData.push({
			health: tower.health,
			x: tower.x,
			y: tower.y,
			isKing: tower.isKing
		});
	}
	storage.savedGame = gameState;
}
// Load game function
function loadGame() {
	var gameState = storage.savedGame;
	if (!gameState) return;
	// Clear existing game state
	for (var i = 0; i < playerUnits.length; i++) {
		playerUnits[i].destroy();
	}
	playerUnits = [];
	for (var i = 0; i < enemyUnits.length; i++) {
		enemyUnits[i].destroy();
	}
	enemyUnits = [];
	for (var i = 0; i < projectiles.length; i++) {
		projectiles[i].destroy();
	}
	projectiles = [];
	// Restore basic game state
	currentEnergy = gameState.currentEnergy || 10;
	playerCups = gameState.playerCups || 100;
	playerDeck = gameState.playerDeck || ['soldier', 'archer', 'tank', 'wizard'];
	// Update UI
	var energyPercent = currentEnergy / maxEnergy;
	energyBar.scaleX = 1.2 * energyPercent;
	energyText.setText(currentEnergy + "/" + maxEnergy);
	updateCupDisplay();
	// Restore player units
	for (var i = 0; i < gameState.playerUnitsData.length; i++) {
		var unitData = gameState.playerUnitsData[i];
		var unit = new Unit(unitData.type, true);
		unit.x = unitData.x;
		unit.y = unitData.y;
		unit.health = unitData.health;
		unit.attackCooldown = unitData.attackCooldown;
		game.addChild(unit);
		playerUnits.push(unit);
	}
	// Restore enemy units
	for (var i = 0; i < gameState.enemyUnitsData.length; i++) {
		var unitData = gameState.enemyUnitsData[i];
		var unit = new Unit(unitData.type, false);
		unit.x = unitData.x;
		unit.y = unitData.y;
		unit.health = unitData.health;
		unit.attackCooldown = unitData.attackCooldown;
		game.addChild(unit);
		enemyUnits.push(unit);
	}
	// Restore towers health
	for (var i = 0; i < gameState.playerTowersData.length && i < playerTowers.length; i++) {
		var towerData = gameState.playerTowersData[i];
		playerTowers[i].health = towerData.health;
		var healthPercent = playerTowers[i].health / playerTowers[i].maxHealth;
		playerTowers[i].children[1].scaleX = 0.4 * healthPercent;
	}
	for (var i = 0; i < gameState.enemyTowersData.length && i < enemyTowers.length; i++) {
		var towerData = gameState.enemyTowersData[i];
		enemyTowers[i].health = towerData.health;
		var healthPercent = enemyTowers[i].health / enemyTowers[i].maxHealth;
		enemyTowers[i].children[1].scaleX = 0.4 * healthPercent;
	}
	setupPlayerCards();
	mainMenu.visible = false;
	matchInProgress = true;
	matchTimer = 120 * 60; // Reset timer when loading
	matchTimerText.visible = true;
	inOvertime = false;
	matchTimerText.tint = 0xFFFFFF; // Reset timer color
}
// Button interactions using LK event system
enterMatchBtn.down = function () {
	mainMenu.visible = false;
	matchInProgress = true;
	matchTimer = 120 * 60; // Reset timer to 2 minutes
	matchTimerText.visible = true;
	inOvertime = false;
	matchTimerText.tint = 0xFFFFFF; // Reset timer color
};
myCardsBtn.down = function () {
	deckBuilder.show();
};
vsBtn.down = function () {
	mainMenu.visible = false;
};
shopBtn.down = function () {
	// Shop functionality to be added
};
saveBtn.down = function () {
	saveGame();
};
loadBtn.down = function () {
	loadGame();
};
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 updateMatchTimer() {
	// Don't update timer when deck builder is open or match is not in progress
	if (deckBuilder.isOpen || !matchInProgress) {
		return;
	}
	matchTimer--;
	if (matchTimer < 0) matchTimer = 0;
	// Update timer display
	var minutes = Math.floor(matchTimer / (60 * 60));
	var seconds = Math.floor(matchTimer % (60 * 60) / 60);
	var timeString = (inOvertime ? "UZATMA " : "") + minutes + ":" + (seconds < 10 ? "0" : "") + seconds;
	matchTimerText.setText(timeString);
	// Check if time is up
	if (matchTimer <= 0) {
		if (!inOvertime) {
			// Enter overtime - add 1 minute
			inOvertime = true;
			matchTimer = 60 * 60; // 1 minute in frames
			matchTimerText.tint = 0xFF0000; // Make timer red for overtime
		} else {
			matchInProgress = false;
			// Determine winner based on tower health total
			var playerTowerHealth = 0;
			var enemyTowerHealth = 0;
			for (var i = 0; i < playerTowers.length; i++) {
				if (playerTowers[i].health > 0) {
					playerTowerHealth += playerTowers[i].health;
				}
			}
			for (var i = 0; i < enemyTowers.length; i++) {
				if (enemyTowers[i].health > 0) {
					enemyTowerHealth += enemyTowers[i].health;
				}
			}
			if (playerTowerHealth > enemyTowerHealth) {
				// Player wins - has more tower health remaining
				playerCups += 30;
				storage.playerCups = playerCups;
				LK.showYouWin();
			} else if (enemyTowerHealth > playerTowerHealth) {
				// Enemy wins - has more tower health remaining
				playerCups -= 5;
				if (playerCups < 0) playerCups = 0;
				storage.playerCups = playerCups;
				LK.showGameOver();
			} else {
				// Draw - same tower health
				game.destroy();
				location.reload();
			}
		}
	}
}
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.15 && 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 (actionType < 0.25 && enemyEnergy >= 5) {
			// Deploy freeze spell - enemy can target player area
			var freezeX = 600 + Math.random() * 800;
			var freezeY = 1500 + Math.random() * 500; // Only in player area
			// Create freeze projectile
			var freezeProjectile = game.addChild(LK.getAsset('freeze', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: 1024,
				y: 600
			}));
			// Animate projectile to target location
			tween(freezeProjectile, {
				x: freezeX,
				y: freezeY
			}, {
				duration: 800,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Create freeze effect area
					var freezeRadius = 150;
					// Freeze all player units in radius for 3 seconds with rotation
					for (var i = 0; i < playerUnits.length; i++) {
						var unit = playerUnits[i];
						if (unit && unit.health > 0) {
							var dx = unit.x - freezeX;
							var dy = unit.y - freezeY;
							var distance = Math.sqrt(dx * dx + dy * dy);
							if (distance < freezeRadius) {
								// Store original move speed
								if (!unit.originalMoveSpeed) unit.originalMoveSpeed = unit.moveSpeed;
								// Freeze unit (stop movement)
								unit.moveSpeed = 0;
								// Add spinning rotation effect
								tween(unit, {
									rotation: unit.rotation + Math.PI * 6
								}, {
									duration: 3000,
									easing: tween.linear
								});
								// Restore movement after 3 seconds
								LK.setTimeout(function () {
									if (unit && unit.health > 0) {
										unit.moveSpeed = unit.originalMoveSpeed;
									}
								}, 3000);
							}
						}
					}
					// Visual effects
					LK.effects.flashScreen(0x87CEEB, 300);
					// Remove freeze projectile
					freezeProjectile.destroy();
				}
			});
			enemyEnergy -= 5;
		} else if (actionType < 0.35 && enemyEnergy >= 3) {
			// Deploy poison spell - enemy can target player area
			var poisonX = 600 + Math.random() * 800;
			var poisonY = 1500 + Math.random() * 500; // Only in player area
			// Create poison effect circle
			var poisonEffect = game.addChild(LK.getAsset('poison', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: poisonX,
				y: poisonY,
				scaleX: 2,
				scaleY: 2
			}));
			poisonEffect.tint = 0x9ACD32; // Yellow-green poison color
			poisonEffect.alpha = 0.7;
			// Create poison damage area indicator circle
			var poisonAreaCircle = game.addChild(LK.getAsset('centerCircle', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: poisonX,
				y: poisonY,
				scaleX: 2.4,
				scaleY: 2.4
			}));
			poisonAreaCircle.tint = 0x9ACD32; // Yellow-green for poison area
			poisonAreaCircle.alpha = 0.3;
			// Create poison damage area
			var poisonRadius = 120;
			var poisonDamage = 80;
			// 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 - poisonX;
					var dy = unit.y - poisonY;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < poisonRadius) {
						unit.takeDamage(poisonDamage);
					}
				}
			}
			// 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 - poisonX;
					var dy = tower.y - poisonY;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < poisonRadius) {
						tower.takeDamage(poisonDamage);
					}
				}
			}
			// Visual effects
			LK.effects.flashScreen(0x9ACD32, 300);
			// Remove poison effect and area circle after 5 seconds
			LK.setTimeout(function () {
				poisonEffect.destroy();
				poisonAreaCircle.destroy();
			}, 5000);
			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' || selectedCard.type === 'freeze' || selectedCard.type === 'poison')) {
		// Show targeting circle for fireball, freeze, and poison
		targetingCircle.visible = true;
		targetingCircle.x = x;
		targetingCircle.y = y;
		// Change circle color based on spell type
		if (selectedCard.type === 'freeze') {
			targetingCircle.tint = 0x87CEEB; // Light blue for freeze
		} else if (selectedCard.type === 'poison') {
			targetingCircle.tint = 0x9ACD32; // Yellow-green for poison
		} else {
			targetingCircle.tint = 0xFFFFFF; // White for fireball
		}
	} 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 deployment area depends on overtime status
			var fireballAllowed = false;
			if (inOvertime) {
				// During overtime, fireball can be used in player's own territory (below centerline)
				fireballAllowed = y > 1366 && y < 2200 && x > 300 && x < 1748;
			} else {
				// Normal time, fireball can only be deployed in enemy area (above centerline)
				fireballAllowed = y > 600 && y < 1366 && x > 300 && x < 1748;
			}
			if (fireballAllowed && currentEnergy >= selectedCard.cost) {
				// Create fireball projectile that travels like freeze
				var fireballProjectile = game.addChild(LK.getAsset('fireball', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 1024,
					y: 2200
				}));
				// Animate projectile to target location
				tween(fireballProjectile, {
					x: x,
					y: y
				}, {
					duration: 800,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						// 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 projectile
						fireballProjectile.destroy();
					}
				});
				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);
					// Get current card types in hand to avoid duplicates
					var currentTypesFireball = [];
					for (var j = 0; j < playerCards.length; j++) {
						if (playerCards[j] && playerCards[j] !== selectedCard) {
							currentTypesFireball.push(playerCards[j].type);
						}
					}
					// Select a card type not currently in hand if possible
					var availableTypesFireball = playerDeck.filter(function (type) {
						return currentTypesFireball.indexOf(type) === -1;
					});
					// If all types are in hand, select randomly from deck
					var newCardType;
					if (availableTypesFireball.length > 0) {
						newCardType = availableTypesFireball[Math.floor(Math.random() * availableTypesFireball.length)];
					} else {
						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 (selectedCard.type === 'poison') {
			// Hide targeting circle
			targetingCircle.visible = false;
			// Poison can be thrown anywhere on the field
			if (currentEnergy >= selectedCard.cost) {
				// Create poison effect circle that damages units in area
				var poisonEffect = game.addChild(LK.getAsset('poison', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: x,
					y: y,
					scaleX: 2,
					scaleY: 2
				}));
				poisonEffect.tint = 0x9ACD32; // Yellow-green poison color
				poisonEffect.alpha = 0.7;
				// Create poison damage area indicator circle
				var poisonAreaCircle = game.addChild(LK.getAsset('centerCircle', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: x,
					y: y,
					scaleX: 2.4,
					scaleY: 2.4
				}));
				poisonAreaCircle.tint = 0x9ACD32; // Yellow-green for poison area
				poisonAreaCircle.alpha = 0.3;
				// Create poison damage area
				var poisonRadius = 120;
				var poisonDamage = 80;
				// Damage all units in radius immediately
				for (var i = 0; i < playerUnits.length; i++) {
					var unit = playerUnits[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 < poisonRadius) {
							unit.takeDamage(poisonDamage);
						}
					}
				}
				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 < poisonRadius) {
							unit.takeDamage(poisonDamage);
						}
					}
				}
				// Damage towers in radius
				for (var i = 0; i < playerTowers.length; i++) {
					var tower = playerTowers[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 < poisonRadius) {
							tower.takeDamage(poisonDamage);
						}
					}
				}
				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 < poisonRadius) {
							tower.takeDamage(poisonDamage);
						}
					}
				}
				// Visual effects
				LK.effects.flashScreen(0x9ACD32, 300);
				// Remove poison effect and area circle after 5 seconds
				LK.setTimeout(function () {
					poisonEffect.destroy();
					poisonAreaCircle.destroy();
				}, 5000);
				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);
					// Get current card types in hand to avoid duplicates
					var currentTypesPoison = [];
					for (var j = 0; j < playerCards.length; j++) {
						if (playerCards[j] && playerCards[j] !== selectedCard) {
							currentTypesPoison.push(playerCards[j].type);
						}
					}
					// Select a card type not currently in hand if possible
					var availableTypesPoison = playerDeck.filter(function (type) {
						return currentTypesPoison.indexOf(type) === -1;
					});
					// If all types are in hand, select randomly from deck
					var newCardType;
					if (availableTypesPoison.length > 0) {
						newCardType = availableTypesPoison[Math.floor(Math.random() * availableTypesPoison.length)];
					} else {
						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 (selectedCard.type === 'freeze') {
			// Hide targeting circle
			targetingCircle.visible = false;
			// Freeze can be thrown anywhere on the field
			if (currentEnergy >= selectedCard.cost) {
				// Create freeze projectile that travels like fireball
				var freezeProjectile = game.addChild(LK.getAsset('freeze', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 1024,
					y: 2200
				}));
				// Animate projectile to target location
				tween(freezeProjectile, {
					x: x,
					y: y
				}, {
					duration: 800,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						// Create freeze effect area
						var freezeRadius = 150;
						// Freeze all units in radius for 3 seconds with rotation
						for (var i = 0; i < playerUnits.length; i++) {
							var unit = playerUnits[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 < freezeRadius) {
									// Store original move speed
									if (!unit.originalMoveSpeed) unit.originalMoveSpeed = unit.moveSpeed;
									// Freeze unit (stop movement)
									unit.moveSpeed = 0;
									// Add spinning rotation effect
									tween(unit, {
										rotation: unit.rotation + Math.PI * 6
									}, {
										duration: 3000,
										easing: tween.linear
									});
									// Restore movement after 3 seconds
									LK.setTimeout(function () {
										if (unit && unit.health > 0) {
											unit.moveSpeed = unit.originalMoveSpeed;
										}
									}, 3000);
								}
							}
						}
						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 < freezeRadius) {
									// Store original move speed
									if (!unit.originalMoveSpeed) unit.originalMoveSpeed = unit.moveSpeed;
									// Freeze unit (stop movement)
									unit.moveSpeed = 0;
									// Add spinning rotation effect
									tween(unit, {
										rotation: unit.rotation + Math.PI * 6
									}, {
										duration: 3000,
										easing: tween.linear
									});
									// Restore movement after 3 seconds
									LK.setTimeout(function () {
										if (unit && unit.health > 0) {
											unit.moveSpeed = unit.originalMoveSpeed;
										}
									}, 3000);
								}
							}
						}
						// Visual effects
						LK.effects.flashScreen(0x87CEEB, 300);
						// Remove freeze projectile
						freezeProjectile.destroy();
					}
				});
				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);
					// Get current card types in hand to avoid duplicates
					var currentTypesFreeze = [];
					for (var j = 0; j < playerCards.length; j++) {
						if (playerCards[j] && playerCards[j] !== selectedCard) {
							currentTypesFreeze.push(playerCards[j].type);
						}
					}
					// Select a card type not currently in hand if possible
					var availableTypesFreeze = playerDeck.filter(function (type) {
						return currentTypesFreeze.indexOf(type) === -1;
					});
					// If all types are in hand, select randomly from deck
					var newCardType;
					if (availableTypesFreeze.length > 0) {
						newCardType = availableTypesFreeze[Math.floor(Math.random() * availableTypesFreeze.length)];
					} else {
						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);
					// Get current card types in hand to avoid duplicates
					var currentTypes = [];
					for (var j = 0; j < playerCards.length; j++) {
						if (playerCards[j] && playerCards[j] !== selectedCard) {
							currentTypes.push(playerCards[j].type);
						}
					}
					// Select a card type not currently in hand if possible
					var availableTypes = playerDeck.filter(function (type) {
						return currentTypes.indexOf(type) === -1;
					});
					// If all types are in hand, select randomly from deck
					var newCardType;
					if (availableTypes.length > 0) {
						newCardType = availableTypes[Math.floor(Math.random() * availableTypes.length)];
					} else {
						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();
	updateMatchTimer();
	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
@@ -1228,8 +1228,19 @@
 				scaleY: 2
 			}));
 			poisonEffect.tint = 0x9ACD32; // Yellow-green poison color
 			poisonEffect.alpha = 0.7;
+			// Create poison damage area indicator circle
+			var poisonAreaCircle = game.addChild(LK.getAsset('centerCircle', {
+				anchorX: 0.5,
+				anchorY: 0.5,
+				x: poisonX,
+				y: poisonY,
+				scaleX: 2.4,
+				scaleY: 2.4
+			}));
+			poisonAreaCircle.tint = 0x9ACD32; // Yellow-green for poison area
+			poisonAreaCircle.alpha = 0.3;
 			// Create poison damage area
 			var poisonRadius = 120;
 			var poisonDamage = 80;
 			// Damage all player units in radius
@@ -1257,12 +1268,13 @@
 				}
 			}
 			// Visual effects
 			LK.effects.flashScreen(0x9ACD32, 300);
-			// Remove poison effect after 2 seconds
+			// Remove poison effect and area circle after 5 seconds
 			LK.setTimeout(function () {
 				poisonEffect.destroy();
-			}, 2000);
+				poisonAreaCircle.destroy();
+			}, 5000);
 			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
@@ -1418,8 +1430,19 @@
 					scaleY: 2
 				}));
 				poisonEffect.tint = 0x9ACD32; // Yellow-green poison color
 				poisonEffect.alpha = 0.7;
+				// Create poison damage area indicator circle
+				var poisonAreaCircle = game.addChild(LK.getAsset('centerCircle', {
+					anchorX: 0.5,
+					anchorY: 0.5,
+					x: x,
+					y: y,
+					scaleX: 2.4,
+					scaleY: 2.4
+				}));
+				poisonAreaCircle.tint = 0x9ACD32; // Yellow-green for poison area
+				poisonAreaCircle.alpha = 0.3;
 				// Create poison damage area
 				var poisonRadius = 120;
 				var poisonDamage = 80;
 				// Damage all units in radius immediately
@@ -1469,12 +1492,13 @@
 					}
 				}
 				// Visual effects
 				LK.effects.flashScreen(0x9ACD32, 300);
-				// Remove poison effect after 2 seconds
+				// Remove poison effect and area circle after 5 seconds
 				LK.setTimeout(function () {
 					poisonEffect.destroy();
-				}, 2000);
+					poisonAreaCircle.destroy();
+				}, 5000);
 				currentEnergy -= selectedCard.cost;
 				var energyPercent = currentEnergy / maxEnergy;
 				energyBar.scaleX = 1.2 * energyPercent;
 				energyText.setText(currentEnergy + "/" + maxEnergy);