/**** 
* 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 () {
		var closestDistance = Infinity;
		var closestTarget = null;
		// Find closest enemy tower
		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];
				}
			}
		}
		// Also check for enemy units in range
		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];
				}
			}
		}
		self.target = closestTarget;
	};
	self.moveToTarget = function () {
		if (!self.target || self.target.isDead) {
			self.findTarget();
			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.range) {
			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;
		var distance = Math.sqrt(Math.pow(self.x - self.target.x, 2) + Math.pow(self.y - self.target.y, 2));
		if (distance <= self.range && LK.ticks - self.lastAttackTime > self.attackSpeed) {
			// Create bullet
			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 check if current target is still valid
		if (self.target && self.target.isDead) {
			self.target = null;
		}
		self.findTarget();
		self.moveToTarget();
		self.attack();
	};
	return self;
});
var Knight = Unit.expand(function (isPlayer) {
	var self = Unit.call(this, isPlayer, 'knight', 825, 160, 60, 168, 2);
	// Range increased from 120 to 168 (40% increase)
	return self;
});
var Archer = Unit.expand(function (isPlayer) {
	var self = Unit.call(this, isPlayer, 'archer', 425, 75, 90, 756, 1.5);
	// Range increased from 540 to 756 (40% increase)
	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 756 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.8 seconds (168 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 = 168; // Ticks for 2.8 seconds at 60fps
var lastElixirRegen = 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;
	// 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);
		}
		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);
		}
		game.addChild(unit);
		LK.getSound('deploy').play();
		return true;
	}
	return false;
}
function aiDeploy() {
	if (LK.ticks - aiLastDeploy > aiDeployInterval && Math.random() < 0.7) {
		var cardTypes = ['archer', 'knight'];
		var randomCard = cardTypes[Math.floor(Math.random() * cardTypes.length)];
		var randomX = 300 + Math.random() * 1448;
		var randomY = 200 + Math.random() * 1000;
		if (deployUnit(randomCard, randomX, randomY, false)) {
			aiLastDeploy = LK.ticks;
			// Randomize next deploy interval (4-6 seconds)
			aiDeployInterval = 240 + 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;
	}
	// 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();
};