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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function (startX, startY, target, damage, isFromPlayer) {
	var self = Container.call(this);
	self.x = startX;
	self.y = startY;
	self.target = target;
	self.damage = damage;
	self.speed = 8;
	self.isFromPlayer = isFromPlayer;
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bulletGraphics.tint = isFromPlayer ? 0x4CAF50 : 0xF44336;
	self.update = function () {
		if (!self.target || self.target.isDead) {
			self.destroy();
			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 < 20) {
			self.target.takeDamage(self.damage);
			self.destroy();
			return;
		}
		var moveX = dx / distance * self.speed;
		var moveY = dy / distance * self.speed;
		self.x += moveX;
		self.y += moveY;
	};
	return self;
});
var Card = Container.expand(function (cardType) {
	var self = Container.call(this);
	self.cardType = cardType;
	self.cost = 3;
	var cardBg = self.attachAsset('cardSlot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var cardIcon = LK.getAsset(cardType, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8
	});
	self.addChild(cardIcon);
	var costText = new Text2(self.cost.toString(), {
		size: 30,
		fill: 0xFFFFFF
	});
	costText.anchor.set(0.5, 0.5);
	costText.x = 120;
	costText.y = -40;
	self.addChild(costText);
	return self;
});
var Tower = Container.expand(function (isPlayer, isKing) {
	var self = Container.call(this);
	self.isPlayer = isPlayer;
	self.isKing = isKing;
	self.maxHealth = isKing ? 3700 : 2400;
	self.currentHealth = self.maxHealth;
	self.isDead = false;
	self.range = 800;
	self.damage = 75;
	self.attackSpeed = 67; // 50% slower than 45 ticks (45 * 1.5 = 67.5, rounded to 67)
	self.lastAttackTime = 0;
	var towerGraphics = self.attachAsset(isKing ? 'kingTower' : 'tower', {
		anchorX: 0.5,
		anchorY: 1
	});
	towerGraphics.tint = self.isPlayer ? 0x4CAF50 : 0xF44336;
	// Health display
	var healthText = new Text2(self.currentHealth.toString(), {
		size: 40,
		fill: 0xFFFFFF
	});
	healthText.anchor.set(0.5, 0.5);
	healthText.y = -75;
	self.addChild(healthText);
	self.healthText = healthText;
	self.takeDamage = function (damage) {
		self.currentHealth -= damage;
		if (self.currentHealth <= 0) {
			self.currentHealth = 0;
			self.isDead = true;
			towersDestroyed++;
			LK.effects.flashObject(self, 0xFF0000, 1000);
			LK.getSound('towerDestroy').play();
			if (self.isPlayer) {
				enemyTowersDestroyed++;
			} else {
				playerTowersDestroyed++;
			}
		}
		self.healthText.setText(self.currentHealth.toString());
		LK.effects.flashObject(self, 0xFF0000, 300);
	};
	self.attack = function () {
		if (self.isDead) return;
		// King towers cannot attack until at least one Princess tower is destroyed
		if (self.isKing) {
			var teamTowers = self.isPlayer ? playerTowers : enemyTowers;
			var princessTowersAlive = 0;
			for (var i = 0; i < teamTowers.length; i++) {
				if (!teamTowers[i].isKing && !teamTowers[i].isDead) {
					princessTowersAlive++;
				}
			}
			if (princessTowersAlive === 2) {
				return; // King tower cannot attack while both Princess towers are alive
			}
		}
		var targetUnits = self.isPlayer ? enemyUnits : playerUnits;
		var closestTarget = null;
		var closestDistance = Infinity;
		for (var i = 0; i < targetUnits.length; i++) {
			if (!targetUnits[i].isDead) {
				var distance = Math.sqrt(Math.pow(self.x - targetUnits[i].x, 2) + Math.pow(self.y - targetUnits[i].y, 2));
				if (distance <= self.range && distance < closestDistance) {
					closestDistance = distance;
					closestTarget = targetUnits[i];
				}
			}
		}
		if (closestTarget && LK.ticks - self.lastAttackTime > self.attackSpeed) {
			var bullet = new Bullet(self.x, self.y - 50, closestTarget, self.damage, self.isPlayer);
			bullets.push(bullet);
			game.addChild(bullet);
			self.lastAttackTime = LK.ticks;
			LK.getSound('attack').play();
		}
	};
	self.update = function () {
		self.attack();
	};
	return self;
});
var Unit = Container.expand(function (isPlayer, unitType, health, damage, attackSpeed, range, speed) {
	var self = Container.call(this);
	self.isPlayer = isPlayer;
	self.unitType = unitType;
	self.maxHealth = health;
	self.currentHealth = health;
	self.damage = damage;
	self.attackSpeed = attackSpeed;
	self.range = range;
	self.speed = speed;
	self.target = null;
	self.lastAttackTime = 0;
	self.isDead = false;
	var unitGraphics = self.attachAsset(unitType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Health bar background
	var healthBarBg = LK.getAsset('cardSlot', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.2,
		scaleY: 0.1,
		y: -50
	});
	healthBarBg.tint = 0x000000;
	self.addChild(healthBarBg);
	// Health bar
	var healthBar = LK.getAsset('cardSlot', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.2,
		scaleY: 0.1,
		y: -50
	});
	healthBar.tint = self.isPlayer ? 0x4CAF50 : 0xF44336;
	self.addChild(healthBar);
	self.healthBar = healthBar;
	self.takeDamage = function (damage) {
		self.currentHealth -= damage;
		if (self.currentHealth <= 0) {
			self.currentHealth = 0;
			self.isDead = true;
		}
		// Update health bar
		var healthPercent = self.currentHealth / self.maxHealth;
		self.healthBar.scaleX = 0.2 * healthPercent;
		// Flash red when taking damage
		LK.effects.flashObject(self, 0xFF0000, 300);
	};
	self.findTarget = function () {
		// Reset target if current target is dead or invalid
		if (self.target && self.target.isDead) {
			self.target = null;
		}
		var closestDistance = Infinity;
		var closestTarget = null;
		// First priority: Find closest enemy units (they are more immediate threats)
		var targetUnits = self.isPlayer ? enemyUnits : playerUnits;
		for (var i = 0; i < targetUnits.length; i++) {
			if (!targetUnits[i].isDead) {
				var distance = Math.sqrt(Math.pow(self.x - targetUnits[i].x, 2) + Math.pow(self.y - targetUnits[i].y, 2));
				if (distance <= self.range && distance < closestDistance) {
					closestDistance = distance;
					closestTarget = targetUnits[i];
				}
			}
		}
		// Second priority: Find closest enemy towers if no units in range
		if (!closestTarget) {
			var targetTowers = self.isPlayer ? enemyTowers : playerTowers;
			for (var i = 0; i < targetTowers.length; i++) {
				if (!targetTowers[i].isDead) {
					var distance = Math.sqrt(Math.pow(self.x - targetTowers[i].x, 2) + Math.pow(self.y - targetTowers[i].y, 2));
					if (distance < closestDistance) {
						closestDistance = distance;
						closestTarget = targetTowers[i];
					}
				}
			}
		}
		self.target = closestTarget;
	};
	self.moveToTarget = function () {
		if (!self.target || self.target.isDead) {
			return;
		}
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Use attack range for movement positioning, not detection range
		var attackRange = self.unitType === 'knight' ? 168 : self.range;
		if (distance > attackRange) {
			var moveX = dx / distance * self.speed;
			var moveY = dy / distance * self.speed;
			self.x += moveX;
			self.y += moveY;
		}
	};
	self.attack = function () {
		if (!self.target || self.target.isDead) return;
		// Verify target is from opposing team before attacking
		var isValidTarget = false;
		if (self.isPlayer && enemyUnits.indexOf(self.target) !== -1) isValidTarget = true;
		if (self.isPlayer && enemyTowers.indexOf(self.target) !== -1) isValidTarget = true;
		if (!self.isPlayer && playerUnits.indexOf(self.target) !== -1) isValidTarget = true;
		if (!self.isPlayer && playerTowers.indexOf(self.target) !== -1) isValidTarget = true;
		if (!isValidTarget) {
			self.target = null;
			return;
		}
		var distance = Math.sqrt(Math.pow(self.x - self.target.x, 2) + Math.pow(self.y - self.target.y, 2));
		// Use different ranges for detection vs attack
		var attackRange = self.unitType === 'knight' ? 168 : self.range; // Knights have shorter attack range than detection
		if (distance <= attackRange && LK.ticks - self.lastAttackTime > self.attackSpeed) {
			// Knight uses melee attack - direct damage without bullet
			if (self.unitType === 'knight') {
				self.target.takeDamage(self.damage);
				// Visual effect for sword strike
				LK.effects.flashObject(self, 0xFFFFFF, 200);
				// Only apply knockback to units, not towers
				var isTargetUnit = playerUnits.indexOf(self.target) !== -1 || enemyUnits.indexOf(self.target) !== -1;
				if (isTargetUnit) {
					// Slight knockback effect only for units
					var knockbackX = (self.target.x - self.x) * 0.1;
					var knockbackY = (self.target.y - self.y) * 0.1;
					if (self.target.x !== undefined) {
						self.target.x += knockbackX;
						self.target.y += knockbackY;
					}
				}
			} else {
				// Other units (like archers) still use bullets
				var bullet = new Bullet(self.x, self.y, self.target, self.damage, self.isPlayer);
				bullets.push(bullet);
				game.addChild(bullet);
			}
			self.lastAttackTime = LK.ticks;
			LK.getSound('attack').play();
		}
	};
	self.update = function () {
		if (self.isDead) return;
		// Always find targets every frame to ensure units never ignore enemies
		self.findTarget();
		self.moveToTarget();
		self.attack();
	};
	return self;
});
var Knight = Unit.expand(function (isPlayer) {
	var self = Unit.call(this, isPlayer, 'knight', 825, 160, 60, 538, 2);
	// Detection range set to 538 (same as archer for consistent detection)
	// Attack range remains at melee distance in attack function
	return self;
});
var Archer = Unit.expand(function (isPlayer) {
	var self = Unit.call(this, isPlayer, 'archer', 425, 75, 90, 538, 1.5);
	// Range reduced by 30% from 756 to 538 (25% + 5%)
	return self;
});

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

/**** 
* Game Code
****/ 
/*
CARD AND TOWER STATS:
TOWERS:
- Princess Towers: 2400 HP, 75 damage, attacks every 1.1s (67 ticks), range 800 units
- King Tower: 3700 HP, 75 damage, attacks every 1.1s (67 ticks), range 800 units
* King tower cannot attack until at least one Princess tower is destroyed
CARDS:
- Archers: 3 elixir cost, 425 HP each, 75 damage, attacks every 1.5s (90 ticks), range 567 units, speed 1.5
* Deploys 2 archers, can attack air and ground targets
- Knight: 3 elixir cost, 825 HP, 160 damage, attacks every 1s (60 ticks), range 168 units, speed 2
* Single melee unit, ground targets only
ELIXIR SYSTEM:
- Maximum: 10 elixir
- Regeneration: 1 elixir every 2.3 seconds (138 ticks at 60fps)
- Starting amount: 5 elixir
GAME RULES:
- Match duration: 2 minutes (120 seconds)
- Victory: Most towers destroyed wins
- Tiebreaker: Remaining tower health
- Draw: Equal towers destroyed and equal remaining health
*/
var gameTime = 120; // 2 minutes in seconds
var elixir = 5; // Starting elixir
var maxElixir = 10;
var elixirRegenRate = 120; // Ticks for 2.0 seconds at 60fps
var lastElixirRegen = 0;
var aiElixir = 5; // AI starting elixir
var aiMaxElixir = 10;
var aiElixirRegenRate = 120; // Ticks for 2 seconds at 60fps (faster than player)
var lastAiElixirRegen = 0;
var playerUnits = [];
var enemyUnits = [];
var bullets = [];
var playerTowers = [];
var enemyTowers = [];
var playerTowersDestroyed = 0;
var enemyTowersDestroyed = 0;
var towersDestroyed = 0;
var gameEnded = false;
var aiLastDeploy = 0;
var aiDeployInterval = 240; // 4 seconds
// Create battlefield divider
var battlefieldLine = game.addChild(LK.getAsset('battlefield', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 1366
}));
battlefieldLine.tint = 0x000000;
battlefieldLine.alpha = 0.3;
// Create towers
// Player towers (bottom)
var playerLeftTower = game.addChild(new Tower(true, false));
playerLeftTower.x = 512;
playerLeftTower.y = 2400;
playerTowers.push(playerLeftTower);
var playerRightTower = game.addChild(new Tower(true, false));
playerRightTower.x = 1536;
playerRightTower.y = 2400;
playerTowers.push(playerRightTower);
var playerKingTower = game.addChild(new Tower(true, true));
playerKingTower.x = 1024;
playerKingTower.y = 2600;
playerTowers.push(playerKingTower);
// Enemy towers (top)
var enemyLeftTower = game.addChild(new Tower(false, false));
enemyLeftTower.x = 512;
enemyLeftTower.y = 400;
enemyTowers.push(enemyLeftTower);
var enemyRightTower = game.addChild(new Tower(false, false));
enemyRightTower.x = 1536;
enemyRightTower.y = 400;
enemyTowers.push(enemyRightTower);
var enemyKingTower = game.addChild(new Tower(false, true));
enemyKingTower.x = 1024;
enemyKingTower.y = 200;
enemyTowers.push(enemyKingTower);
// UI Elements
var timerText = new Text2(gameTime.toString(), {
	size: 60,
	fill: 0xFFFFFF
});
timerText.anchor.set(0.5, 0);
LK.gui.top.addChild(timerText);
var elixirText = new Text2(elixir + "/" + maxElixir, {
	size: 40,
	fill: 0xE91E63
});
elixirText.anchor.set(0, 1);
elixirText.x = 50;
LK.gui.bottomLeft.addChild(elixirText);
// Cards
var archerCard = LK.gui.bottom.addChild(new Card('archer'));
archerCard.x = -200;
archerCard.y = -100;
var knightCard = LK.gui.bottom.addChild(new Card('knight'));
knightCard.x = 200;
knightCard.y = -100;
// Dragging variables
var draggedCard = null;
var dragOffset = {
	x: 0,
	y: 0
};
function deployUnit(cardType, x, y, isPlayer) {
	if (isPlayer && elixir < 3) return false;
	if (!isPlayer && aiElixir < 3) return false; // AI also needs elixir
	// Check if position is in correct half
	if (isPlayer && y < 1366) return false; // Player can only deploy in bottom half
	if (!isPlayer && y > 1366) return false; // AI can only deploy in top half
	var unit = null;
	if (cardType === 'archer') {
		// Deploy 2 archers
		var archer1 = new Archer(isPlayer);
		var archer2 = new Archer(isPlayer);
		archer1.x = x - 40; // Left archer
		archer1.y = y;
		archer2.x = x + 40; // Right archer
		archer2.y = y;
		if (isPlayer) {
			playerUnits.push(archer1);
			playerUnits.push(archer2);
			elixir -= 3;
			elixirText.setText(elixir + "/" + maxElixir);
		} else {
			enemyUnits.push(archer1);
			enemyUnits.push(archer2);
			aiElixir -= 3; // Deduct AI elixir
		}
		game.addChild(archer1);
		game.addChild(archer2);
		LK.getSound('deploy').play();
		return true;
	} else if (cardType === 'knight') {
		unit = new Knight(isPlayer);
	}
	if (unit) {
		unit.x = x;
		unit.y = y;
		if (isPlayer) {
			playerUnits.push(unit);
			elixir -= 3;
			elixirText.setText(elixir + "/" + maxElixir);
		} else {
			enemyUnits.push(unit);
			aiElixir -= 3; // Deduct AI elixir
		}
		game.addChild(unit);
		LK.getSound('deploy').play();
		return true;
	}
	return false;
}
var aiLastUsedCard = null;
var aiCardCooldown = {};
function aiDeploy() {
	if (LK.ticks - aiLastDeploy > aiDeployInterval && Math.random() < 0.7 && aiElixir >= 3) {
		var cardTypes = ['archer', 'knight'];
		// Filter out cards that are on cooldown or were just used
		var availableCards = cardTypes.filter(function (card) {
			return card !== aiLastUsedCard && (!aiCardCooldown[card] || LK.ticks - aiCardCooldown[card] > 300);
		});
		// If no cards available, use any card
		if (availableCards.length === 0) {
			availableCards = cardTypes;
		}
		var randomCard = availableCards[Math.floor(Math.random() * availableCards.length)];
		// Smart positioning based on player unit concentration
		var playerSide = 'center';
		var leftCount = 0;
		var rightCount = 0;
		// Count player units on each side
		for (var i = 0; i < playerUnits.length; i++) {
			if (playerUnits[i].x < 1024) {
				leftCount++;
			} else {
				rightCount++;
			}
		}
		var deployX, deployY;
		// 70% chance to counter player concentration, 30% chance to attack opposite side
		if (Math.random() < 0.7) {
			if (leftCount > rightCount) {
				// Deploy on left side to counter
				deployX = 300 + Math.random() * 500;
			} else if (rightCount > leftCount) {
				// Deploy on right side to counter
				deployX = 1200 + Math.random() * 500;
			} else {
				// Balanced, deploy randomly
				deployX = 300 + Math.random() * 1448;
			}
		} else {
			// Strategic opposite side deployment
			if (leftCount > rightCount) {
				deployX = 1200 + Math.random() * 500; // Attack right while player focused left
			} else {
				deployX = 300 + Math.random() * 500; // Attack left while player focused right
			}
		}
		deployY = 200 + Math.random() * 1000;
		if (deployUnit(randomCard, deployX, deployY, false)) {
			aiLastDeploy = LK.ticks;
			aiLastUsedCard = randomCard;
			aiCardCooldown[randomCard] = LK.ticks;
			// Randomize next deploy interval (3-5 seconds for more dynamic play)
			aiDeployInterval = 180 + Math.random() * 120;
		}
	}
}
function checkGameEnd() {
	if (gameTime <= 0 && !gameEnded) {
		gameEnded = true;
		if (playerTowersDestroyed > enemyTowersDestroyed) {
			LK.showGameOver();
		} else if (enemyTowersDestroyed > playerTowersDestroyed) {
			LK.showYouWin();
		} else {
			// Tie-breaker: check tower health
			var playerTotalHealth = 0;
			var enemyTotalHealth = 0;
			for (var i = 0; i < playerTowers.length; i++) {
				playerTotalHealth += playerTowers[i].currentHealth;
			}
			for (var i = 0; i < enemyTowers.length; i++) {
				enemyTotalHealth += enemyTowers[i].currentHealth;
			}
			if (playerTotalHealth > enemyTotalHealth) {
				LK.showYouWin();
			} else if (enemyTotalHealth > playerTotalHealth) {
				LK.showGameOver();
			} else {
				LK.showGameOver(); // Draw counts as loss
			}
		}
	}
}
// Event handlers
archerCard.down = function (x, y, obj) {
	if (elixir >= 3) {
		draggedCard = 'archer';
	}
};
knightCard.down = function (x, y, obj) {
	if (elixir >= 3) {
		draggedCard = 'knight';
	}
};
game.down = function (x, y, obj) {
	// This will handle deployment when clicking on the battlefield
};
game.up = function (x, y, obj) {
	if (draggedCard) {
		// Convert coordinates to game space
		var gamePos = {
			x: x,
			y: y
		};
		if (obj && obj.parent) {
			var globalPos = obj.parent.toGlobal ? obj.parent.toGlobal(obj.position) : {
				x: x,
				y: y
			};
			gamePos = game.toLocal ? game.toLocal(globalPos) : {
				x: x,
				y: y
			};
		}
		if (deployUnit(draggedCard, gamePos.x, gamePos.y, true)) {
			// Unit deployed successfully
		}
		draggedCard = null;
	}
};
game.update = function () {
	if (gameEnded) return;
	// Update timer
	if (LK.ticks % 60 === 0 && gameTime > 0) {
		gameTime--;
		timerText.setText(gameTime.toString());
	}
	// Regenerate elixir
	if (LK.ticks - lastElixirRegen >= elixirRegenRate && elixir < maxElixir) {
		elixir++;
		elixirText.setText(elixir + "/" + maxElixir);
		lastElixirRegen = LK.ticks;
	}
	// Regenerate AI elixir
	if (LK.ticks - lastAiElixirRegen >= aiElixirRegenRate && aiElixir < aiMaxElixir) {
		aiElixir++;
		lastAiElixirRegen = LK.ticks;
	}
	// AI deployment
	aiDeploy();
	// Clean up dead units
	for (var i = playerUnits.length - 1; i >= 0; i--) {
		if (playerUnits[i].isDead) {
			playerUnits[i].destroy();
			playerUnits.splice(i, 1);
		}
	}
	for (var i = enemyUnits.length - 1; i >= 0; i--) {
		if (enemyUnits[i].isDead) {
			enemyUnits[i].destroy();
			enemyUnits.splice(i, 1);
		}
	}
	// Clean up bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		if (bullets[i].destroyed || bullets[i].y < -100 || bullets[i].y > 2800) {
			bullets[i].destroy();
			bullets.splice(i, 1);
		}
	}
	// Check for immediate game end conditions
	var allPlayerTowersDead = true;
	var allEnemyTowersDead = true;
	for (var i = 0; i < playerTowers.length; i++) {
		if (!playerTowers[i].isDead) {
			allPlayerTowersDead = false;
			break;
		}
	}
	for (var i = 0; i < enemyTowers.length; i++) {
		if (!enemyTowers[i].isDead) {
			allEnemyTowersDead = false;
			break;
		}
	}
	if (allPlayerTowersDead && !gameEnded) {
		gameEnded = true;
		LK.showGameOver();
	} else if (allEnemyTowersDead && !gameEnded) {
		gameEnded = true;
		LK.showYouWin();
	}
	checkGameEnd();
};

===================================================================
--- original.js
+++ change.js
@@ -341,9 +341,9 @@
 */
 var gameTime = 120; // 2 minutes in seconds
 var elixir = 5; // Starting elixir
 var maxElixir = 10;
-var elixirRegenRate = 138; // Ticks for 2.3 seconds at 60fps
+var elixirRegenRate = 120; // Ticks for 2.0 seconds at 60fps
 var lastElixirRegen = 0;
 var aiElixir = 5; // AI starting elixir
 var aiMaxElixir = 10;
 var aiElixirRegenRate = 120; // Ticks for 2 seconds at 60fps (faster than player)