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

/**** 
* Classes
****/ 
var EnemyBullet = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('enemyBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 4;
	self.directionX = 0;
	self.directionY = 0;
	self.lifeTime = 0;
	self.maxLifeTime = 180; // 3 seconds at 60fps
	self.consumed = false;
	self.update = function () {
		if (self.consumed) return;
		self.x += self.directionX * self.speed;
		self.y += self.directionY * self.speed;
		self.lifeTime++;
		// Remove bullet if it goes out of bounds or expires
		if (self.x < 0 || self.x > arenaWidth || self.y < 0 || self.y > arenaHeight || self.lifeTime > self.maxLifeTime) {
			self.consumed = true;
		}
	};
	return self;
});
var EnemyCell = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('enemyCell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.size = 80;
	self.speed = 1;
	self.targetX = self.x;
	self.targetY = self.y;
	self.moveTimer = 0;
	self.consumed = false;
	self.update = function () {
		if (self.consumed) return;
		self.moveTimer++;
		// Chase the player instead of random movement
		self.targetX = player.x;
		self.targetY = player.y;
		// Move towards player
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Only move if not too close (maintain some distance for shooting)
		if (distance > 120) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
		// Shoot at player every 90 frames (1.5 seconds)
		if (self.moveTimer % 90 === 0 && distance < 400) {
			// Create bullet aimed at player
			var bullet = new EnemyBullet();
			bullet.x = self.x;
			bullet.y = self.y;
			// Calculate direction to player
			bullet.directionX = dx / distance;
			bullet.directionY = dy / distance;
			enemyBullets.push(bullet);
			game.addChild(bullet);
			LK.getSound('enemyShoot').play();
		}
		// Check collision with other enemy cells
		for (var i = 0; i < enemyCells.length; i++) {
			var otherEnemy = enemyCells[i];
			if (otherEnemy === self || otherEnemy.consumed) continue;
			var dx = self.x - otherEnemy.x;
			var dy = self.y - otherEnemy.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			var minDistance = (self.size + otherEnemy.size) / 2;
			// If too close, push them apart
			if (distance < minDistance && distance > 0) {
				var pushForce = (minDistance - distance) / 2;
				var pushX = dx / distance * pushForce;
				var pushY = dy / distance * pushForce;
				self.x += pushX;
				self.y += pushY;
				otherEnemy.x -= pushX;
				otherEnemy.y -= pushY;
			}
		}
		// Keep within arena bounds
		if (self.x < self.size / 2) self.x = self.size / 2;
		if (self.x > arenaWidth - self.size / 2) self.x = arenaWidth - self.size / 2;
		if (self.y < self.size / 2) self.y = self.size / 2;
		if (self.y > arenaHeight - self.size / 2) self.y = arenaHeight - self.size / 2;
	};
	self.teleportToRandomLocation = function () {
		// Teleport to a random location far from the house
		var attempts = 0;
		var maxAttempts = 10;
		do {
			self.x = Math.random() * (arenaWidth - 200) + 100;
			self.y = Math.random() * (arenaHeight - 200) + 100;
			// Make sure enemy doesn't teleport too close to house
			var dx = self.x - house.x;
			var dy = self.y - house.y;
			var distanceFromHouse = Math.sqrt(dx * dx + dy * dy);
			attempts++;
			if (distanceFromHouse > 300 || attempts >= maxAttempts) {
				break;
			}
		} while (true);
		// Reset target position
		self.targetX = self.x;
		self.targetY = self.y;
	};
	return self;
});
var FoodParticle = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('foodParticle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.value = 1;
	self.consumed = false;
	return self;
});
var HealthFood = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('healthFood', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.healAmount = 10;
	self.consumed = false;
	return self;
});
var House = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('house', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.size = 150;
	self.playerInside = false;
	self.lastPlayerInside = false;
	self.checkPlayerInside = function (playerX, playerY, playerSize) {
		var dx = playerX - self.x;
		var dy = playerY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		return distance < self.size / 2 - playerSize / 2;
	};
	return self;
});
var PlayerBullet = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('enemyBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Tint player bullets green to distinguish from enemy bullets
	graphics.tint = 0x00ff00;
	self.speed = 6;
	self.directionX = 0;
	self.directionY = 0;
	self.lifeTime = 0;
	self.maxLifeTime = 120; // 2 seconds at 60fps
	self.consumed = false;
	self.update = function () {
		if (self.consumed) return;
		self.x += self.directionX * self.speed;
		self.y += self.directionY * self.speed;
		self.lifeTime++;
		// Remove bullet if it goes out of bounds or expires
		if (self.x < 0 || self.x > arenaWidth || self.y < 0 || self.y > arenaHeight || self.lifeTime > self.maxLifeTime) {
			self.consumed = true;
		}
	};
	return self;
});
var PlayerCell = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('playerCell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.size = 60;
	self.maxSpeed = 3;
	self.targetX = self.x;
	self.targetY = self.y;
	self.lastSize = self.size;
	self.health = 100;
	self.maxHealth = 100;
	self.level = 1;
	self.maxLevel = 100;
	self.speedBoostActive = false;
	self.originalMaxSpeed = self.maxSpeed;
	self.grow = function (amount) {
		// Don't change size - character stays the same size
		// Update score by the amount eaten instead of size-based scoring
		LK.setScore(LK.getScore() + amount);
		scoreTxt.setText(LK.getScore());
		// Update level based on score
		self.updateLevel();
		// Check win condition based on score instead of size
		if (LK.getScore() >= 500) {
			LK.showYouWin();
		}
	};
	self.heal = function (amount) {
		self.health = Math.min(self.maxHealth, self.health + amount);
		healthTxt.setText('Health: ' + self.health);
	};
	self.takeDamage = function (amount) {
		self.health = Math.max(0, self.health - amount);
		healthTxt.setText('Health: ' + self.health);
		if (self.health <= 0) {
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
			return true;
		}
		return false;
	};
	self.updateLevel = function () {
		var newLevel = Math.min(self.maxLevel, Math.floor(LK.getScore() / 100) + 1);
		if (newLevel !== self.level) {
			self.level = newLevel;
			levelTxt.setText('Level: ' + self.level);
		}
	};
	self.activateSpeedBoost = function (boostAmount, duration) {
		if (!self.speedBoostActive) {
			self.speedBoostActive = true;
			self.maxSpeed = self.originalMaxSpeed + boostAmount;
			// Visual effect - blue tint
			tween(graphics, {
				tint: 0x00ffff
			}, {
				duration: 200
			});
			// Remove boost after duration
			LK.setTimeout(function () {
				self.speedBoostActive = false;
				self.maxSpeed = self.originalMaxSpeed;
				// Remove tint
				tween(graphics, {
					tint: 0xffffff
				}, {
					duration: 200
				});
			}, duration);
		}
	};
	self.getSpeed = function () {
		// Speed stays constant since size no longer changes
		return self.maxSpeed;
	};
	self.update = function () {
		// Move towards target position
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 2) {
			var speed = self.getSpeed();
			self.x += dx / distance * speed;
			self.y += dy / distance * speed;
		}
		// Keep within arena bounds
		var radius = self.size / 2;
		if (self.x < radius) self.x = radius;
		if (self.x > arenaWidth - radius) self.x = arenaWidth - radius;
		if (self.y < radius) self.y = radius;
		if (self.y > arenaHeight - radius) self.y = arenaHeight - radius;
	};
	return self;
});
var PlayerWeapon = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('weapon', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.offsetX = 40; // Distance from player
	self.offsetY = 0;
	self.shootTimer = 0;
	self.shootCooldown = 30; // Shoot every 0.5 seconds at 60fps
	self.update = function () {
		// Follow player position with offset
		self.x = player.x + self.offsetX;
		self.y = player.y + self.offsetY;
		// Keep weapon within arena bounds
		if (self.x < 20) self.x = 20;
		if (self.x > arenaWidth - 20) self.x = arenaWidth - 20;
		if (self.y < 20) self.y = 20;
		if (self.y > arenaHeight - 20) self.y = arenaHeight - 20;
		// Shooting logic
		self.shootTimer++;
		if (self.shootTimer >= self.shootCooldown && enemyCells.length > 0) {
			// Find closest enemy
			var closestEnemy = null;
			var closestDistance = Infinity;
			for (var i = 0; i < enemyCells.length; i++) {
				var enemy = enemyCells[i];
				if (enemy.consumed) continue;
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < closestDistance && distance < 300) {
					closestDistance = distance;
					closestEnemy = enemy;
				}
			}
			// Shoot at closest enemy if found
			if (closestEnemy) {
				var bullet = new PlayerBullet();
				bullet.x = self.x;
				bullet.y = self.y;
				// Calculate direction to enemy
				var dx = closestEnemy.x - self.x;
				var dy = closestEnemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				bullet.directionX = dx / distance;
				bullet.directionY = dy / distance;
				playerBullets.push(bullet);
				game.addChild(bullet);
				self.shootTimer = 0;
			}
		}
	};
	return self;
});
var SpeedFood = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('speedFood', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speedBoost = 2;
	self.boostDuration = 3000; // 3 seconds
	self.consumed = false;
	return self;
});
var Weapon = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('weapon', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.consumed = false;
	return self;
});

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

/**** 
* Game Code
****/ 
var arenaWidth = 2048;
var arenaHeight = 2732;
// Create score display
var scoreTxt = new Text2('0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Create health display
var healthTxt = new Text2('Health: 100', {
	size: 60,
	fill: 0x00ff00
});
healthTxt.anchor.set(0, 0);
healthTxt.x = 120;
healthTxt.y = 20;
LK.gui.topLeft.addChild(healthTxt);
// Create level display
var levelTxt = new Text2('Level: 1', {
	size: 60,
	fill: 0xffff00
});
levelTxt.anchor.set(1, 0);
levelTxt.x = -20;
levelTxt.y = 20;
LK.gui.topRight.addChild(levelTxt);
// Game objects
var player;
var house;
var foodParticles = [];
var enemyCells = [];
var enemyBullets = [];
var healthFoods = [];
var speedFoods = [];
var maxFoodParticles = 50;
var maxEnemyCells = 5;
var maxHealthFoods = 8;
var maxSpeedFoods = 5;
var enemySpawnTimer = 0;
var weaponSpawned = false;
var weapons = [];
var playerHasWeapon = false;
var playerWeapon = null;
var playerBullets = [];
var weaponTimer = 0;
var weaponDuration = 300; // 5 seconds at 60fps
// Initialize player
player = game.addChild(new PlayerCell());
player.x = arenaWidth / 2;
player.y = arenaHeight / 2;
// Initialize house
house = game.addChild(new House());
house.x = arenaWidth / 4;
house.y = arenaHeight / 4;
// Create initial food particles
function createFoodParticle() {
	var food = new FoodParticle();
	food.x = Math.random() * (arenaWidth - 100) + 50;
	food.y = Math.random() * (arenaHeight - 100) + 50;
	foodParticles.push(food);
	game.addChild(food);
}
// Create health food
function createHealthFood() {
	var healthFood = new HealthFood();
	healthFood.x = Math.random() * (arenaWidth - 100) + 50;
	healthFood.y = Math.random() * (arenaHeight - 100) + 50;
	healthFoods.push(healthFood);
	game.addChild(healthFood);
}
// Create speed food
function createSpeedFood() {
	var speedFood = new SpeedFood();
	speedFood.x = Math.random() * (arenaWidth - 100) + 50;
	speedFood.y = Math.random() * (arenaHeight - 100) + 50;
	speedFoods.push(speedFood);
	game.addChild(speedFood);
}
// Create initial enemy cells
function createEnemyCell() {
	var enemy = new EnemyCell();
	enemy.x = Math.random() * (arenaWidth - 200) + 100;
	enemy.y = Math.random() * (arenaHeight - 200) + 100;
	// Make sure enemy doesn't spawn too close to player
	var dx = enemy.x - player.x;
	var dy = enemy.y - player.y;
	var distance = Math.sqrt(dx * dx + dy * dy);
	if (distance < 200) {
		enemy.x = player.x + dx / distance * 200;
		enemy.y = player.y + dy / distance * 200;
	}
	enemyCells.push(enemy);
	game.addChild(enemy);
}
// Spawn initial objects
for (var i = 0; i < maxFoodParticles; i++) {
	createFoodParticle();
}
for (var i = 0; i < maxEnemyCells; i++) {
	createEnemyCell();
}
for (var i = 0; i < maxHealthFoods; i++) {
	createHealthFood();
}
for (var i = 0; i < maxSpeedFoods; i++) {
	createSpeedFood();
}
// Touch controls
function handleMove(x, y, obj) {
	player.targetX = x;
	player.targetY = y;
}
game.move = handleMove;
game.down = function (x, y, obj) {
	handleMove(x, y, obj);
};
// Main game loop
game.update = function () {
	// Check collisions with food particles
	for (var i = foodParticles.length - 1; i >= 0; i--) {
		var food = foodParticles[i];
		if (food.consumed) continue;
		var dx = player.x - food.x;
		var dy = player.y - food.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < player.size / 2 + 10) {
			// Player ate food
			food.consumed = true;
			player.grow(3);
			food.destroy();
			foodParticles.splice(i, 1);
			LK.getSound('eat').play();
		}
	}
	// Check collisions with health foods
	for (var i = healthFoods.length - 1; i >= 0; i--) {
		var healthFood = healthFoods[i];
		if (healthFood.consumed) continue;
		var dx = player.x - healthFood.x;
		var dy = player.y - healthFood.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < player.size / 2 + 12) {
			// Player ate health food
			healthFood.consumed = true;
			player.heal(10);
			healthFood.destroy();
			healthFoods.splice(i, 1);
			LK.getSound('eat').play();
		}
	}
	// Check collisions with enemy cells
	for (var i = enemyCells.length - 1; i >= 0; i--) {
		var enemy = enemyCells[i];
		if (enemy.consumed) continue;
		var dx = player.x - enemy.x;
		var dy = player.y - enemy.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		var collisionDistance = player.size / 2 + enemy.size / 2 - 10;
		if (distance < collisionDistance) {
			if (player.size > enemy.size + 20) {
				// Player eats enemy
				enemy.consumed = true;
				player.grow(15);
				enemy.destroy();
				enemyCells.splice(i, 1);
				LK.getSound('absorbed').play();
			} else if (enemy.size > player.size + 20) {
				// Enemy eats player - game over
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
				return;
			}
		}
	}
	// Spawn new food particles
	if (foodParticles.length < maxFoodParticles && LK.ticks % 60 === 0) {
		createFoodParticle();
	}
	// Check collisions with speed foods
	for (var i = speedFoods.length - 1; i >= 0; i--) {
		var speedFood = speedFoods[i];
		if (speedFood.consumed) continue;
		var dx = player.x - speedFood.x;
		var dy = player.y - speedFood.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < player.size / 2 + 15) {
			// Player ate speed food
			speedFood.consumed = true;
			player.activateSpeedBoost(speedFood.speedBoost, speedFood.boostDuration);
			speedFood.destroy();
			speedFoods.splice(i, 1);
			LK.getSound('eat').play();
		}
	}
	// Spawn new health foods
	if (healthFoods.length < maxHealthFoods && LK.ticks % 180 === 0) {
		createHealthFood();
	}
	// Spawn new speed foods
	if (speedFoods.length < maxSpeedFoods && LK.ticks % 240 === 0) {
		createSpeedFood();
	}
	// Check bullet collisions with player
	for (var i = enemyBullets.length - 1; i >= 0; i--) {
		var bullet = enemyBullets[i];
		if (bullet.consumed) {
			bullet.destroy();
			enemyBullets.splice(i, 1);
			continue;
		}
		var dx = player.x - bullet.x;
		var dy = player.y - bullet.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < player.size / 2 + 5) {
			// Bullet hit player - take damage
			var isDead = player.takeDamage(5);
			if (isDead) {
				return;
			}
			bullet.consumed = true;
			bullet.destroy();
			enemyBullets.splice(i, 1);
		}
	}
	// Check player bullet collisions with enemies
	for (var i = playerBullets.length - 1; i >= 0; i--) {
		var bullet = playerBullets[i];
		if (bullet.consumed) {
			bullet.destroy();
			playerBullets.splice(i, 1);
			continue;
		}
		// Check collision with enemies
		var hitEnemy = false;
		for (var j = enemyCells.length - 1; j >= 0; j--) {
			var enemy = enemyCells[j];
			if (enemy.consumed) continue;
			var dx = bullet.x - enemy.x;
			var dy = bullet.y - enemy.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < enemy.size / 2 + 10) {
				// Bullet hit enemy
				enemy.consumed = true;
				player.grow(10); // Give points for killing enemy
				enemy.destroy();
				enemyCells.splice(j, 1);
				LK.getSound('absorbed').play();
				bullet.consumed = true;
				hitEnemy = true;
				break;
			}
		}
		if (hitEnemy) {
			bullet.destroy();
			playerBullets.splice(i, 1);
		}
	}
	// Check if player enters/exits house
	house.lastPlayerInside = house.playerInside;
	house.playerInside = house.checkPlayerInside(player.x, player.y, player.size);
	// If player just entered the house (transition from outside to inside)
	if (!house.lastPlayerInside && house.playerInside) {
		// Teleport all enemies to different locations
		for (var i = 0; i < enemyCells.length; i++) {
			var enemy = enemyCells[i];
			if (!enemy.consumed) {
				enemy.teleportToRandomLocation();
			}
		}
		// Visual effect when entering house
		LK.effects.flashScreen(0x00ff00, 300);
	}
	// Enemy spawning system - increase every 10 seconds up to 10 enemies
	enemySpawnTimer++;
	if (enemySpawnTimer >= 600) {
		// 10 seconds at 60fps
		enemySpawnTimer = 0;
		if (maxEnemyCells < 10) {
			maxEnemyCells++;
		}
	}
	// Spawn new enemy cells to reach target amount
	if (enemyCells.length < maxEnemyCells && LK.ticks % 300 === 0) {
		createEnemyCell();
	}
	// Spawn weapon when we have 10 enemies and haven't spawned one yet
	if (maxEnemyCells >= 10 && !weaponSpawned && weapons.length === 0) {
		var weapon = new Weapon();
		weapon.x = Math.random() * (arenaWidth - 200) + 100;
		weapon.y = Math.random() * (arenaHeight - 200) + 100;
		weapons.push(weapon);
		game.addChild(weapon);
		weaponSpawned = true;
	}
	// Check collisions with weapons
	for (var i = weapons.length - 1; i >= 0; i--) {
		var weapon = weapons[i];
		if (weapon.consumed) continue;
		var dx = player.x - weapon.x;
		var dy = player.y - weapon.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < player.size / 2 + 20) {
			// Player picked up weapon
			weapon.consumed = true;
			weapon.destroy();
			weapons.splice(i, 1);
			LK.getSound('weaponPickup').play();
			// Equip weapon to player
			if (!playerHasWeapon) {
				playerHasWeapon = true;
				playerWeapon = game.addChild(new PlayerWeapon());
				weaponTimer = 0; // Reset weapon timer
				LK.effects.flashScreen(0xffff00, 500);
			}
		}
	}
	// Handle weapon timer and automatic removal
	if (playerHasWeapon && playerWeapon) {
		weaponTimer++;
		if (weaponTimer >= weaponDuration) {
			// Remove weapon after 5 seconds
			playerHasWeapon = false;
			playerWeapon.destroy();
			playerWeapon = null;
			weaponTimer = 0;
			weaponSpawned = false; // Allow new weapon to spawn when we have 10 enemies again
			// Flash effect to indicate weapon removed
			LK.effects.flashScreen(0xff0000, 300);
		}
	}
};