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

/**** 
* Classes
****/ 
var Creature = Container.expand(function (isPlayer) {
	var self = Container.call(this);
	self.isPlayer = isPlayer || false;
	self.health = 100;
	self.maxHealth = 100;
	self.attack = 10;
	self.speed = 2;
	self.size = 1;
	self.level = 1;
	self.resources = {
		orb: 0,
		crystal: 0,
		essence: 0
	};
	self.combatCooldown = 0;
	self.targetX = 0;
	self.targetY = 0;
	self.lastCombatTime = 0;
	var assetName = self.isPlayer ? 'player' : 'ai_creature';
	var graphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.evolve = function () {
		// AI creatures have 30% lower evolution requirements for faster development
		var reductionFactor = self.isPlayer ? 1.0 : 0.7;
		var requiredOrbs = Math.floor(self.level * 8 * reductionFactor);
		var requiredCrystals = Math.floor(self.level * 5 * reductionFactor);
		var requiredEssence = Math.floor(self.level * 3 * reductionFactor);
		if (self.resources.orb >= requiredOrbs && self.resources.crystal >= requiredCrystals && self.resources.essence >= requiredEssence && self.level < 20) {
			self.level++;
			self.size += 0.15;
			self.health += 25 + self.level * 5;
			self.maxHealth += 25 + self.level * 5;
			self.attack += 8 + self.level * 2;
			self.speed += 0.3;
			// Smooth evolution growth animation
			tween(graphics, {
				scaleX: self.size,
				scaleY: self.size
			}, {
				duration: 800,
				easing: tween.easeOut
			});
			self.resources.orb -= requiredOrbs;
			self.resources.crystal -= requiredCrystals;
			self.resources.essence -= requiredEssence;
			LK.getSound('evolve').play();
			LK.effects.flashObject(self, 0xffd700, 500);
			if (self.isPlayer) {
				LK.setScore(self.level * 150 + currentWave * 50);
			}
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.health = 0;
			self.die();
		}
		LK.effects.flashObject(self, 0xff0000, 200);
	};
	self.die = function () {
		if (self.isPlayer) {
			LK.showGameOver();
		} else {
			aiCreatures.splice(aiCreatures.indexOf(self), 1);
			self.destroy();
			// Immediately spawn a stronger replacement enemy
			LK.setTimeout(function () {
				spawnStrongerEnemy();
			}, 1000);
		}
	};
	self.findNearestResource = function () {
		var nearest = null;
		var minDistance = Infinity;
		for (var i = 0; i < resources.length; i++) {
			var resource = resources[i];
			if (resource.collected) continue;
			var dx = resource.x - self.x;
			var dy = resource.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < minDistance) {
				minDistance = distance;
				nearest = resource;
			}
		}
		return nearest;
	};
	self.findBestResource = function () {
		var best = null;
		var bestScore = -1;
		for (var i = 0; i < resources.length; i++) {
			var resource = resources[i];
			if (resource.collected) continue;
			var dx = resource.x - self.x;
			var dy = resource.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			// Calculate score based on value and distance
			var score = resource.value * 100 / (distance + 1);
			// Prefer essence and crystals over orbs
			if (resource.type === 'essence') score *= 3;else if (resource.type === 'crystal') score *= 2;
			if (score > bestScore) {
				bestScore = score;
				best = resource;
			}
		}
		return best || self.findNearestResource();
	};
	self.update = function () {
		if (self.combatCooldown > 0) {
			self.combatCooldown--;
		}
		if (!self.isPlayer) {
			// Calculate distance to player for aggressive behavior
			var playerDx = player.x - self.x;
			var playerDy = player.y - self.y;
			var playerDistance = Math.sqrt(playerDx * playerDx + playerDy * playerDy);
			// More aggressive targeting logic
			var shouldTargetPlayer = false;
			// Elite creatures are very aggressive
			if (self.elite) {
				shouldTargetPlayer = Math.random() < 0.6;
			}
			// Regular creatures become aggressive when they're bigger than player or when close
			else if (self.size > player.size * 1.1 || playerDistance < 200) {
				shouldTargetPlayer = Math.random() < 0.4;
			}
			// All creatures occasionally target player for pressure
			else if (Math.random() < 0.15) {
				shouldTargetPlayer = true;
			}
			if (shouldTargetPlayer) {
				// Aggressive pursuit of player
				self.targetX = player.x;
				self.targetY = player.y;
			} else {
				// Smart resource collection - prefer high value resources
				var target = self.findBestResource();
				if (target) {
					self.targetX = target.x;
					self.targetY = target.y;
				}
			}
			// Enhanced movement with better pathfinding
			var dx = self.targetX - self.x;
			var dy = self.targetY - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > 5) {
				// Increase speed when chasing player aggressively
				var moveSpeed = self.speed;
				if (shouldTargetPlayer && playerDistance < 300) {
					moveSpeed *= 1.5; // 50% speed boost when hunting player
				} else {
					moveSpeed *= 2.3; // 130% speed boost when collecting resources (25-30% faster than before)
				}
				self.x += dx / distance * moveSpeed;
				self.y += dy / distance * moveSpeed;
			}
			// More frequent evolution for aggressive gameplay - increased AI evolution rates
			var evolveChance;
			if (self.isPlayer) {
				evolveChance = 0.01 + self.level * 0.003; // Player evolution rate stays same
			} else {
				evolveChance = self.elite ? 0.055 : 0.025 + self.level * 0.008; // AI evolves 50% more frequently
			}
			if (Math.random() < evolveChance) {
				self.evolve();
			}
		}
		self.x = Math.max(50, Math.min(1998, self.x));
		self.y = Math.max(150, Math.min(2682, self.y));
	};
	return self;
});
var Resource = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'orb';
	self.value = type === 'essence' ? 5 : type === 'crystal' ? 3 : 1;
	var assetName = 'resource_' + self.type;
	var graphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.collected = false;
	self.collect = function (collector) {
		if (self.collected) return;
		self.collected = true;
		LK.getSound('collect').play();
		// Grow the collector based on resource value
		if (collector) {
			var growthAmount = self.value * 0.02; // Each resource point adds 2% size
			var newSize = collector.size + growthAmount;
			collector.size = Math.min(newSize, 5.0); // Cap maximum size at 5x
			// Smooth scaling animation
			tween(collector.getChildAt(0), {
				scaleX: collector.size,
				scaleY: collector.size
			}, {
				duration: 200,
				easing: tween.easeOut
			});
		}
		tween(self, {
			alpha: 0,
			scaleX: 2,
			scaleY: 2
		}, {
			duration: 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var background = game.attachAsset('arena_background', {
	x: 0,
	y: 0
});
var player = game.addChild(new Creature(true));
player.x = 1024;
player.y = 1366;
var aiCreatures = [];
for (var i = 0; i < 12; i++) {
	var ai = game.addChild(new Creature(false));
	ai.x = Math.random() * 1800 + 124;
	ai.y = Math.random() * 2400 + 166;
	ai.targetX = ai.x;
	ai.targetY = ai.y;
	aiCreatures.push(ai);
}
var resources = [];
var maxResources = 120;
// Create organized UI layout with proper spacing and alignment
var waveText = new Text2('Wave: 1', {
	size: 32,
	fill: 0xFFFFFF
});
waveText.anchor.set(0, 0);
waveText.x = 120; // Start after safe area
waveText.y = 20;
LK.gui.topLeft.addChild(waveText);
var sizeText = new Text2('Size: 1.0x', {
	size: 32,
	fill: 0xFFFFFF
});
sizeText.anchor.set(0, 0);
sizeText.x = 240; // 120px spacing from wave
sizeText.y = 20;
LK.gui.topLeft.addChild(sizeText);
var orbText = new Text2('Orbs: 0', {
	size: 32,
	fill: 0xFFFFFF
});
orbText.anchor.set(0, 0);
orbText.x = 380; // 140px spacing from size
orbText.y = 20;
LK.gui.topLeft.addChild(orbText);
var crystalText = new Text2('Crystals: 0', {
	size: 32,
	fill: 0xFFFFFF
});
crystalText.anchor.set(0, 0);
crystalText.x = 500; // 120px spacing from orbs
crystalText.y = 20;
LK.gui.topLeft.addChild(crystalText);
var essenceText = new Text2('Essence: 0', {
	size: 32,
	fill: 0xFFFFFF
});
essenceText.anchor.set(0, 0);
essenceText.x = 640; // 140px spacing from crystals
essenceText.y = 20;
LK.gui.topLeft.addChild(essenceText);
var levelText = new Text2('Level: 1', {
	size: 32,
	fill: 0xFFFFFF
});
levelText.anchor.set(0, 0);
levelText.x = 780; // 140px spacing from essence
levelText.y = 20;
LK.gui.topLeft.addChild(levelText);
var scoreText = new Text2('Score: 0', {
	size: 32,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0, 0);
scoreText.x = 900; // 120px spacing from level
scoreText.y = 20;
LK.gui.topLeft.addChild(scoreText);
var healthText = new Text2('Health: 100/100', {
	size: 32,
	fill: 0xFFFFFF
});
healthText.anchor.set(0, 0);
healthText.x = 1040; // 140px spacing from score
healthText.y = 20;
LK.gui.topLeft.addChild(healthText);
function spawnResource() {
	if (resources.length >= maxResources) return;
	var types = ['orb', 'crystal', 'essence'];
	var weights = [0.6, 0.3, 0.1];
	var random = Math.random();
	var type = 'orb';
	if (random < weights[2]) type = 'essence';else if (random < weights[1] + weights[2]) type = 'crystal';
	var resource = game.addChild(new Resource(type));
	resource.x = Math.random() * 1800 + 124;
	resource.y = Math.random() * 2400 + 166;
	resources.push(resource);
	tween(resource, {
		alpha: 0.8
	}, {
		duration: 500,
		easing: tween.easeOut
	});
}
function checkCombat() {
	var allCreatures = [player].concat(aiCreatures);
	for (var i = 0; i < allCreatures.length; i++) {
		for (var j = i + 1; j < allCreatures.length; j++) {
			var creature1 = allCreatures[i];
			var creature2 = allCreatures[j];
			if (creature1.combatCooldown > 0 || creature2.combatCooldown > 0) continue;
			if (creature1.health <= 0 || creature2.health <= 0) continue;
			var dx = creature1.x - creature2.x;
			var dy = creature1.y - creature2.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			var consumeRange = Math.max(creature1.size, creature2.size) * 50;
			if (distance < consumeRange) {
				// Size-based consumption: larger creature consumes smaller one
				var sizeDifference = Math.abs(creature1.size - creature2.size);
				if (sizeDifference > 0.5) {
					// Need significant size difference to consume
					var larger, smaller;
					if (creature1.size > creature2.size) {
						larger = creature1;
						smaller = creature2;
					} else {
						larger = creature2;
						smaller = creature1;
					}
					// Consumption happens - smaller creature gets absorbed
					LK.getSound('combat').play();
					LK.effects.flashObject(larger, 0x00ff00, 500);
					LK.effects.flashObject(smaller, 0xff0000, 300);
					// Larger creature grows from consuming the smaller one
					var growthBonus = smaller.size * 0.3;
					larger.size += growthBonus;
					larger.size = Math.min(larger.size, 8.0); // Cap at 8x size
					larger.health += smaller.maxHealth * 0.5;
					larger.maxHealth += smaller.maxHealth * 0.5;
					// Transfer some resources
					larger.resources.orb += Math.floor(smaller.resources.orb * 0.7);
					larger.resources.crystal += Math.floor(smaller.resources.crystal * 0.7);
					larger.resources.essence += Math.floor(smaller.resources.essence * 0.7);
					// Animate growth
					tween(larger.getChildAt(0), {
						scaleX: larger.size,
						scaleY: larger.size
					}, {
						duration: 500,
						easing: tween.easeOut
					});
					// Remove consumed creature
					smaller.die();
					larger.combatCooldown = 120; // Longer cooldown after consuming
				} else {
					// Traditional combat if size difference is small
					var damage1 = creature1.attack + Math.random() * 10;
					var damage2 = creature2.attack + Math.random() * 10;
					creature1.takeDamage(damage2);
					creature2.takeDamage(damage1);
					creature1.combatCooldown = 60;
					creature2.combatCooldown = 60;
					LK.getSound('combat').play();
				}
			}
		}
	}
}
var dragActive = false;
game.down = function (x, y, obj) {
	dragActive = true;
	// Reduced movement speed for better control - move 30% towards target position
	var dx = x - player.x;
	var dy = y - player.y;
	player.x += dx * 0.3;
	player.y += dy * 0.3;
};
game.move = function (x, y, obj) {
	if (dragActive) {
		// Reduced movement speed for better control - move 30% towards target position
		var dx = x - player.x;
		var dy = y - player.y;
		player.x += dx * 0.3;
		player.y += dy * 0.3;
	}
};
game.up = function (x, y, obj) {
	dragActive = false;
};
game.update = function () {
	for (var i = resources.length - 1; i >= 0; i--) {
		var resource = resources[i];
		if (resource.collected) {
			resources.splice(i, 1);
			continue;
		}
		var allCreatures = [player].concat(aiCreatures);
		for (var j = 0; j < allCreatures.length; j++) {
			var creature = allCreatures[j];
			if (creature.health <= 0) continue;
			var dx = creature.x - resource.x;
			var dy = creature.y - resource.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			// AI creatures have larger collection range for faster resource gathering
			var collectRange = creature.isPlayer ? creature.size * 40 : creature.size * 50;
			if (distance < collectRange) {
				creature.resources[resource.type] += resource.value;
				resource.collect(creature); // Pass creature reference for size growth
				break;
			}
		}
	}
	checkCombat();
	if (LK.ticks % 30 === 0) {
		spawnResource();
	}
	// Spawn additional resources more frequently
	if (LK.ticks % 90 === 0) {
		for (var r = 0; r < 3; r++) {
			spawnResource();
		}
	}
	if (LK.ticks % 300 === 0) {
		player.evolve();
	}
	// Continuous enemy spawning - spawn new enemy when count gets low
	var minEnemies = Math.max(8, currentWave * 2); // Minimum enemies scales with wave
	if (aiCreatures.length < minEnemies) {
		var enemiesToSpawn = Math.min(4, minEnemies - aiCreatures.length);
		for (var k = 0; k < enemiesToSpawn; k++) {
			spawnStrongerEnemy();
		}
		LK.effects.flashScreen(0xffff00, 500);
	}
	// Periodically spawn additional aggressive enemies
	if (LK.ticks % 600 === 0) {
		// Every 10 seconds
		spawnStrongerEnemy();
	}
	// Spawn next wave
	if (waveStartTime > 0 && LK.ticks >= waveStartTime) {
		spawnWave();
		waveStartTime = 0;
	}
	// Enhanced resource spawning based on wave
	if (LK.ticks % (100 - currentWave * 5) === 0) {
		spawnResource();
	}
	// Update all UI elements separately for better organization and readability
	waveText.setText('Wave: ' + currentWave);
	sizeText.setText('Size: ' + player.size.toFixed(1) + 'x');
	orbText.setText('Orbs: ' + player.resources.orb);
	crystalText.setText('Crystals: ' + player.resources.crystal);
	essenceText.setText('Essence: ' + player.resources.essence);
	levelText.setText('Level: ' + player.level);
	scoreText.setText('Score: ' + LK.getScore());
	healthText.setText('Health: ' + Math.ceil(player.health) + '/' + player.maxHealth);
};
var currentWave = 1;
var enemiesPerWave = 8;
var waveStartTime = 0;
function spawnWave() {
	var enemiesToSpawn = enemiesPerWave + (currentWave - 1) * 2;
	for (var i = 0; i < enemiesToSpawn; i++) {
		var ai = game.addChild(new Creature(false));
		ai.x = Math.random() * 1800 + 124;
		ai.y = Math.random() * 2400 + 166;
		ai.targetX = ai.x;
		ai.targetY = ai.y;
		// Make enemies progressively stronger each wave - enhanced scaling
		ai.level = Math.max(1, Math.floor(currentWave / 1.5)); // Start with higher levels sooner
		ai.health += ai.level * 35 + currentWave * 12; // Increased base health scaling
		ai.maxHealth += ai.level * 35 + currentWave * 12;
		ai.attack += ai.level * 8 + currentWave * 4; // Doubled attack scaling
		ai.speed += currentWave * 0.15; // Increased speed scaling
		ai.size += currentWave * 0.08; // Increased size scaling
		// Give AI creatures starting resources for immediate evolution potential
		ai.resources.orb = Math.floor(currentWave * 2 + ai.level * 1.5);
		ai.resources.crystal = Math.floor(currentWave * 1.2 + ai.level * 0.8);
		ai.resources.essence = Math.floor(currentWave * 0.6 + ai.level * 0.4);
		// Create elite enemies every 3rd wave
		if (currentWave % 3 === 0 && i < 2) {
			ai.elite = true;
			ai.health *= 2;
			ai.maxHealth *= 2;
			ai.attack *= 1.5;
			ai.size *= 1.3;
			var graphics = ai.getChildAt(0);
			graphics.tint = 0x8e44ad;
			graphics.scaleX = ai.size;
			graphics.scaleY = ai.size;
		}
		aiCreatures.push(ai);
	}
	LK.effects.flashScreen(0x00ff00, 500);
}
for (var i = 0; i < 50; i++) {
	spawnResource();
}
function spawnStrongerEnemy() {
	var ai = game.addChild(new Creature(false));
	ai.x = Math.random() * 1800 + 124;
	ai.y = Math.random() * 2400 + 166;
	ai.targetX = ai.x;
	ai.targetY = ai.y;
	// Make the new enemy stronger based on current wave and time
	var strengthMultiplier = Math.floor(LK.ticks / 3600) + currentWave; // Gets stronger over time
	ai.level = Math.max(1, strengthMultiplier);
	ai.health += ai.level * 35 + strengthMultiplier * 15; // Increased health
	ai.maxHealth += ai.level * 35 + strengthMultiplier * 15;
	ai.attack += ai.level * 8 + strengthMultiplier * 4; // Increased attack
	ai.speed += strengthMultiplier * 0.2; // Increased speed
	ai.size += strengthMultiplier * 0.12; // Increased size
	// Give new enemies substantial starting resources to make them more competitive
	ai.resources.orb = Math.floor(strengthMultiplier * 5 + currentWave * 2);
	ai.resources.crystal = Math.floor(strengthMultiplier * 3 + currentWave * 1.5);
	ai.resources.essence = Math.floor(strengthMultiplier * 2 + currentWave * 0.8);
	// Higher chance for elite enemy increases over time
	if (Math.random() < 0.35 + strengthMultiplier * 0.15) {
		ai.elite = true;
		ai.health *= 2.2;
		ai.maxHealth *= 2.2;
		ai.attack *= 1.7;
		ai.size *= 1.4;
		var graphics = ai.getChildAt(0);
		graphics.tint = 0x8e44ad;
		graphics.scaleX = ai.size;
		graphics.scaleY = ai.size;
	}
	aiCreatures.push(ai);
	LK.effects.flashObject(ai, 0xff6b6b, 1000);
}
LK.playMusic('arena_music');
;
;