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

/**** 
* Classes
****/ 
/**** 
* Bullet System
****/ 
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.target = null;
	self.damage = 25;
	self.speed = 8;
	self.type = 'basic';
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.activate = function (startX, startY, target, damage, type) {
		self.active = true;
		self.x = startX;
		self.y = startY;
		self.target = target;
		self.damage = damage;
		self.type = type;
		self.visible = true;
		// Set bullet appearance based on type
		switch (type) {
			case 'rapid':
				bulletGraphics.tint = 0x00AAFF;
				bulletGraphics.width = bulletGraphics.height = 10;
				break;
			case 'sniper':
				bulletGraphics.tint = 0xFF5500;
				bulletGraphics.width = bulletGraphics.height = 8;
				self.speed = 15;
				break;
			case 'splash':
				bulletGraphics.tint = 0x33CC00;
				bulletGraphics.width = bulletGraphics.height = 20;
				break;
			case 'slow':
				bulletGraphics.tint = 0x9900FF;
				bulletGraphics.width = bulletGraphics.height = 15;
				break;
			case 'poison':
				bulletGraphics.tint = 0x00FFAA;
				bulletGraphics.width = bulletGraphics.height = 15;
				break;
			default:
				bulletGraphics.tint = 0xFFFF00;
				bulletGraphics.width = bulletGraphics.height = 15;
				break;
		}
	};
	self.update = function () {
		if (!self.active || !self.target || !self.target.active) {
			PoolManager.returnBullet(self);
			return;
		}
		// Move toward target
		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.speed) {
			// Hit target
			self.target.takeDamage(self.damage);
			// Special effects based on bullet type
			if (self.type === 'splash') {
				self.createSplashDamage();
			}
			PoolManager.returnBullet(self);
		} else {
			// Move toward target
			var angle = Math.atan2(dy, dx);
			self.x += Math.cos(angle) * self.speed;
			self.y += Math.sin(angle) * self.speed;
		}
	};
	self.createSplashDamage = function () {
		var splashRadius = 60;
		for (var i = 0; i < PoolManager.enemies.length; i++) {
			var enemy = PoolManager.enemies[i];
			if (!enemy.active || enemy === self.target) continue;
			var distance = CoordUtils.distance(self.x, self.y, enemy.x, enemy.y);
			if (distance <= splashRadius) {
				enemy.takeDamage(self.damage * 0.5);
			}
		}
	};
	return self;
});
/**** 
* Embryo System
****/ 
var Embryo = Container.expand(function () {
	var self = Container.call(this);
	self.level = 1;
	self.experience = 0;
	self.maxExperience = 100;
	self.baseSize = 80;
	self.currentSize = self.baseSize;
	self.aspectRatio = 1.0; // Will become elliptical as it grows
	// Growth stages
	self.growthStages = [{
		level: 1,
		size: 80,
		slots: 4,
		ratio: 1.0,
		exp: 0
	}, {
		level: 2,
		size: 100,
		slots: 6,
		ratio: 1.1,
		exp: 100
	}, {
		level: 3,
		size: 120,
		slots: 8,
		ratio: 1.2,
		exp: 250
	}, {
		level: 4,
		size: 140,
		slots: 10,
		ratio: 1.3,
		exp: 450
	}, {
		level: 5,
		size: 160,
		slots: 12,
		ratio: 1.4,
		exp: 700
	}, {
		level: 6,
		size: 180,
		slots: 14,
		ratio: 1.5,
		exp: 1000
	}];
	// Visual components
	var embryoGraphics = self.attachAsset('embryo', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var coreGraphics = self.attachAsset('embryoCore', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.orbitalSlots = [];
	self.getCurrentStage = function () {
		for (var i = self.growthStages.length - 1; i >= 0; i--) {
			if (self.experience >= self.growthStages[i].exp) {
				return self.growthStages[i];
			}
		}
		return self.growthStages[0];
	};
	self.initializeOrbitalSlots = function () {
		var currentStage = self.getCurrentStage();
		var slotCount = currentStage.slots;
		var radius = currentStage.size + 60;
		self.orbitalSlots = [];
		for (var i = 0; i < slotCount; i++) {
			var angle = i / slotCount * Math.PI * 2;
			self.orbitalSlots.push({
				angle: angle,
				radius: radius,
				occupied: false,
				tower: null,
				speed: 0.02 // radians per frame
			});
		}
	};
	self.initializeOrbitalSlots();
	self.addExperience = function (amount) {
		var prevLevel = self.level;
		self.experience += amount;
		var newStage = self.getCurrentStage();
		if (newStage.level > prevLevel) {
			self.levelUp(newStage);
		}
	};
	self.levelUp = function (newStage) {
		self.level = newStage.level;
		self.currentSize = newStage.size;
		self.aspectRatio = newStage.ratio;
		// Animate growth
		tween(embryoGraphics, {
			width: self.currentSize,
			height: self.currentSize * self.aspectRatio
		}, {
			duration: 1000,
			easing: tween.elasticOut
		});
		tween(coreGraphics, {
			width: self.currentSize * 0.6,
			height: self.currentSize * 0.6 * self.aspectRatio
		}, {
			duration: 1000,
			easing: tween.elasticOut
		});
		// Reinitialize orbital slots
		self.initializeOrbitalSlots();
		// Notification
		var notification = game.addChild(new Notification("Embryo Level Up! New slots available!"));
		notification.x = SCREEN_WIDTH / 2;
		notification.y = SCREEN_HEIGHT / 2;
	};
	self.getAvailableSlot = function () {
		for (var i = 0; i < self.orbitalSlots.length; i++) {
			if (!self.orbitalSlots[i].occupied) {
				return self.orbitalSlots[i];
			}
		}
		return null;
	};
	self.update = function () {
		// Breathing animation
		var breathScale = 1 + Math.sin(LK.ticks * 0.05) * 0.05;
		coreGraphics.scaleX = breathScale;
		coreGraphics.scaleY = breathScale;
		// Update orbital slots
		for (var i = 0; i < self.orbitalSlots.length; i++) {
			var slot = self.orbitalSlots[i];
			slot.angle = CoordUtils.normalizeAngle(slot.angle + slot.speed);
			if (slot.tower) {
				var pos = CoordUtils.polarToCartesian(slot.radius, slot.angle);
				slot.tower.x = self.x + pos.x;
				slot.tower.y = self.y + pos.y;
			}
		}
	};
	return self;
});
/**** 
* Enemy System
****/ 
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.material = 'slime';
	self.health = 100;
	self.maxHealth = 100;
	self.speed = 1;
	self.bounceTimer = 0;
	self.bounceHeight = 1;
	// Visual components
	var blobGraphics = self.attachAsset('blob', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var healthBarOutline = self.attachAsset('healthBarOutline', {
		anchorX: 0,
		anchorY: 0.5
	});
	var healthBar = self.attachAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	// Position health bars
	healthBarOutline.y = healthBar.y = -30;
	healthBarOutline.x = -36;
	healthBar.x = -35;
	healthBar.tint = 0x00ff00;
	self.activate = function (material, spawnAngle) {
		self.active = true;
		self.material = material || 'slime';
		self.health = self.maxHealth;
		self.bounceTimer = 0;
		// Set material properties
		self.setMaterial(self.material);
		// Position at edge of screen
		var spawnRadius = Math.max(SCREEN_WIDTH, SCREEN_HEIGHT) * 0.6;
		var pos = CoordUtils.polarToCartesian(spawnRadius, spawnAngle);
		self.x = SCREEN_WIDTH / 2 + pos.x;
		self.y = SCREEN_HEIGHT / 2 + pos.y;
		self.visible = true;
	};
	self.setMaterial = function (material) {
		switch (material) {
			case 'slime':
				blobGraphics.tint = 0x00FF00;
				self.speed = 1;
				break;
			case 'metal':
				blobGraphics.tint = 0xC0C0C0;
				self.speed = 0.8;
				self.maxHealth = 150;
				break;
			case 'lava':
				blobGraphics.tint = 0xFF4500;
				self.speed = 1.2;
				break;
			case 'ice':
				blobGraphics.tint = 0x87CEEB;
				self.speed = 0.7;
				break;
			case 'shadow':
				blobGraphics.tint = 0x4B0082;
				self.speed = 1.5;
				break;
		}
		self.health = self.maxHealth;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		healthBar.width = self.health / self.maxHealth * 70;
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		// Create death particles
		self.createDeathEffect();
		// Give experience to embryo
		embryo.addExperience(10);
		// Give gold to player
		setGold(gold + 5);
		// Return to pool
		PoolManager.returnEnemy(self);
	};
	self.createDeathEffect = function () {
		var particleCount = 8;
		for (var i = 0; i < particleCount; i++) {
			var particle = PoolManager.getParticle();
			if (particle) {
				particle.activate(self.x, self.y, self.material);
				gameLayer.addChild(particle);
			}
		}
	};
	self.update = function () {
		if (!self.active) return;
		// Move toward embryo center
		var dx = embryo.x - self.x;
		var dy = embryo.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Check if reached embryo
		if (distance < embryo.currentSize / 2 + 20) {
			// Damage player
			lives--;
			updateUI();
			PoolManager.returnEnemy(self);
			return;
		}
		// Move toward center
		var angle = Math.atan2(dy, dx);
		self.x += Math.cos(angle) * self.speed;
		self.y += Math.sin(angle) * self.speed;
		// Bounce animation
		self.bounceTimer += 0.2;
		var bounceScale = 1 + Math.sin(self.bounceTimer) * 0.2;
		blobGraphics.scaleY = bounceScale;
		blobGraphics.scaleX = 2 - bounceScale; // Squash and stretch
	};
	return self;
});
/**** 
* Notification System
****/ 
var Notification = Container.expand(function (message) {
	var self = Container.call(this);
	var bg = self.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var text = new Text2(message, {
		size: 40,
		fill: 0x000000,
		weight: 800
	});
	text.anchor.set(0.5, 0.5);
	self.addChild(text);
	bg.width = text.width + 40;
	bg.height = text.height + 20;
	self.alpha = 0;
	// Fade in
	tween(self, {
		alpha: 1
	}, {
		duration: 300,
		onFinish: function onFinish() {
			// Fade out after delay
			setTimeout(function () {
				tween(self, {
					alpha: 0
				}, {
					duration: 300,
					onFinish: function onFinish() {
						self.destroy();
					}
				});
			}, 2000);
		}
	});
	return self;
});
/**** 
* Particle System
****/ 
var Particle = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.life = 60;
	self.maxLife = 60;
	self.velocityX = 0;
	self.velocityY = 0;
	var particleGraphics = self.attachAsset('particle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.activate = function (x, y, material) {
		self.active = true;
		self.x = x;
		self.y = y;
		self.life = self.maxLife;
		self.visible = true;
		// Random velocity
		var angle = Math.random() * Math.PI * 2;
		var speed = 2 + Math.random() * 4;
		self.velocityX = Math.cos(angle) * speed;
		self.velocityY = Math.sin(angle) * speed;
		// Set color based on material
		switch (material) {
			case 'slime':
				particleGraphics.tint = 0x00FF00;
				break;
			case 'metal':
				particleGraphics.tint = 0xC0C0C0;
				break;
			case 'lava':
				particleGraphics.tint = 0xFF4500;
				break;
			case 'ice':
				particleGraphics.tint = 0x87CEEB;
				break;
			case 'shadow':
				particleGraphics.tint = 0x4B0082;
				break;
			default:
				particleGraphics.tint = 0xFFFFFF;
				break;
		}
		self.scaleX = self.scaleY = 1;
		self.alpha = 1;
	};
	self.update = function () {
		if (!self.active) return;
		self.life--;
		if (self.life <= 0) {
			PoolManager.returnParticle(self);
			return;
		}
		// Move
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Fade out
		var lifeRatio = self.life / self.maxLife;
		self.alpha = lifeRatio;
		self.scaleX = self.scaleY = lifeRatio;
		// Gravity
		self.velocityY += 0.1;
		self.velocityX *= 0.98;
	};
	return self;
});
/**** 
* Wave System
****/ 
/**** 
* Tower System
****/ 
var Tower = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'basic';
	self.level = 1;
	self.damage = 25;
	self.range = 120;
	self.fireRate = 60; // frames between shots
	self.lastFired = 0;
	self.orbitalSlot = null;
	// Visual components
	var baseGraphics = self.attachAsset('tower', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var gunContainer = new Container();
	self.addChild(gunContainer);
	var gunGraphics = gunContainer.attachAsset('defense', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set tower properties based on type
	self.setType = function (type) {
		self.type = type;
		switch (type) {
			case 'rapid':
				baseGraphics.tint = 0x00AAFF;
				self.fireRate = 30;
				self.damage = 15;
				self.range = 100;
				break;
			case 'sniper':
				baseGraphics.tint = 0xFF5500;
				self.fireRate = 90;
				self.damage = 60;
				self.range = 180;
				break;
			case 'splash':
				baseGraphics.tint = 0x33CC00;
				self.fireRate = 75;
				self.damage = 35;
				self.range = 80;
				break;
			case 'slow':
				baseGraphics.tint = 0x9900FF;
				self.fireRate = 50;
				self.damage = 20;
				self.range = 110;
				break;
			case 'poison':
				baseGraphics.tint = 0x00FFAA;
				self.fireRate = 70;
				self.damage = 30;
				self.range = 90;
				break;
			default:
				baseGraphics.tint = 0xAAAAAA;
				break;
		}
	};
	self.setType(type);
	self.findTarget = function () {
		var closestEnemy = null;
		var closestDistance = Infinity;
		for (var i = 0; i < PoolManager.enemies.length; i++) {
			var enemy = PoolManager.enemies[i];
			if (!enemy.active) continue;
			var distance = CoordUtils.distance(self.x, self.y, enemy.x, enemy.y);
			if (distance <= self.range && distance < closestDistance) {
				closestDistance = distance;
				closestEnemy = enemy;
			}
		}
		return closestEnemy;
	};
	self.fire = function (target) {
		var bullet = PoolManager.getBullet();
		if (bullet) {
			bullet.activate(self.x, self.y, target, self.damage, self.type);
			gameLayer.addChild(bullet);
		}
		// Recoil animation
		tween.stop(gunContainer, {
			scaleX: true,
			scaleY: true
		});
		gunContainer.scaleX = 0.8;
		gunContainer.scaleY = 0.8;
		tween(gunContainer, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 150,
			easing: tween.elasticOut
		});
	};
	self.update = function () {
		// Find and shoot at enemies
		if (LK.ticks - self.lastFired >= self.fireRate) {
			var target = self.findTarget();
			if (target) {
				// Aim at target
				var dx = target.x - self.x;
				var dy = target.y - self.y;
				var angle = Math.atan2(dy, dx);
				gunContainer.rotation = angle;
				self.fire(target);
				self.lastFired = LK.ticks;
			}
		}
	};
	return self;
});
/**** 
* UI System
****/ 
var TowerSelector = Container.expand(function () {
	var self = Container.call(this);
	self.towerTypes = ['basic', 'rapid', 'sniper', 'splash', 'slow', 'poison'];
	self.buttons = [];
	var buttonWidth = 100;
	var spacing = 120;
	var startX = -((self.towerTypes.length - 1) * spacing) / 2;
	self.createTowerButton = function (type, index) {
		var button = new Container();
		var bg = button.attachAsset('tower', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		bg.width = bg.height = buttonWidth;
		// Set color based on type
		switch (type) {
			case 'rapid':
				bg.tint = 0x00AAFF;
				break;
			case 'sniper':
				bg.tint = 0xFF5500;
				break;
			case 'splash':
				bg.tint = 0x33CC00;
				break;
			case 'slow':
				bg.tint = 0x9900FF;
				break;
			case 'poison':
				bg.tint = 0x00FFAA;
				break;
			default:
				bg.tint = 0xAAAAAA;
				break;
		}
		var label = new Text2(type, {
			size: 24,
			fill: 0xFFFFFF,
			weight: 800
		});
		label.anchor.set(0.5, 0.5);
		button.addChild(label);
		button.down = function () {
			self.placeTower(type);
		};
		return button;
	};
	self.placeTower = function (type) {
		var slot = embryo.getAvailableSlot();
		if (slot && gold >= self.getTowerCost(type)) {
			var tower = new Tower(type);
			tower.orbitalSlot = slot;
			slot.occupied = true;
			slot.tower = tower;
			gameLayer.addChild(tower);
			setGold(gold - self.getTowerCost(type));
			var notification = new Notification("Tower placed!");
			game.addChild(notification);
			notification.x = SCREEN_WIDTH / 2;
			notification.y = SCREEN_HEIGHT / 2 + 100;
		} else if (!slot) {
			var notification = new Notification("No available slots!");
			game.addChild(notification);
			notification.x = SCREEN_WIDTH / 2;
			notification.y = SCREEN_HEIGHT / 2 + 100;
		} else {
			var notification = new Notification("Not enough gold!");
			game.addChild(notification);
			notification.x = SCREEN_WIDTH / 2;
			notification.y = SCREEN_HEIGHT / 2 + 100;
		}
	};
	self.getTowerCost = function (type) {
		switch (type) {
			case 'rapid':
				return 25;
			case 'sniper':
				return 40;
			case 'splash':
				return 50;
			case 'slow':
				return 60;
			case 'poison':
				return 70;
			default:
				return 15;
		}
	};
	for (var i = 0; i < self.towerTypes.length; i++) {
		var button = self.createTowerButton(self.towerTypes[i], i);
		button.x = startX + i * spacing;
		self.addChild(button);
		self.buttons.push(button);
	}
	return self;
});

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

/**** 
* Game Code
****/ 
/**** 
* Object Pooling System
****/ 
var PoolManager = {
	enemies: [],
	bullets: [],
	particles: [],
	init: function init() {
		// Pre-allocate pools
		for (var i = 0; i < 200; i++) {
			this.enemies.push(this.createEnemy());
		}
		for (var i = 0; i < 500; i++) {
			this.bullets.push(this.createBullet());
		}
		for (var i = 0; i < 1000; i++) {
			this.particles.push(this.createParticle());
		}
	},
	getEnemy: function getEnemy() {
		for (var i = 0; i < this.enemies.length; i++) {
			if (!this.enemies[i].active) {
				return this.enemies[i];
			}
		}
		// If pool exhausted, create new one
		var enemy = this.createEnemy();
		this.enemies.push(enemy);
		return enemy;
	},
	getBullet: function getBullet() {
		for (var i = 0; i < this.bullets.length; i++) {
			if (!this.bullets[i].active) {
				return this.bullets[i];
			}
		}
		var bullet = this.createBullet();
		this.bullets.push(bullet);
		return bullet;
	},
	getParticle: function getParticle() {
		for (var i = 0; i < this.particles.length; i++) {
			if (!this.particles[i].active) {
				return this.particles[i];
			}
		}
		var particle = this.createParticle();
		this.particles.push(particle);
		return particle;
	},
	createEnemy: function createEnemy() {
		var enemy = new Enemy();
		enemy.active = false;
		return enemy;
	},
	createBullet: function createBullet() {
		var bullet = new Bullet();
		bullet.active = false;
		return bullet;
	},
	createParticle: function createParticle() {
		var particle = new Particle();
		particle.active = false;
		return particle;
	},
	returnEnemy: function returnEnemy(enemy) {
		enemy.active = false;
		if (enemy.parent) {
			enemy.parent.removeChild(enemy);
		}
	},
	returnBullet: function returnBullet(bullet) {
		bullet.active = false;
		if (bullet.parent) {
			bullet.parent.removeChild(bullet);
		}
	},
	returnParticle: function returnParticle(particle) {
		particle.active = false;
		if (particle.parent) {
			particle.parent.removeChild(particle);
		}
	}
};
/**** 
* Coordinate System Utilities
****/ 
var CoordUtils = {
	// Convert polar to cartesian coordinates
	polarToCartesian: function polarToCartesian(radius, angle) {
		return {
			x: radius * Math.cos(angle),
			y: radius * Math.sin(angle)
		};
	},
	// Convert cartesian to polar coordinates
	cartesianToPolar: function cartesianToPolar(x, y) {
		var radius = Math.sqrt(x * x + y * y);
		var angle = Math.atan2(y, x);
		return {
			radius: radius,
			angle: angle
		};
	},
	// Get distance between two points
	distance: function distance(x1, y1, x2, y2) {
		var dx = x2 - x1;
		var dy = y2 - y1;
		return Math.sqrt(dx * dx + dy * dy);
	},
	// Normalize angle to 0-2π range
	normalizeAngle: function normalizeAngle(angle) {
		while (angle < 0) angle += Math.PI * 2;
		while (angle >= Math.PI * 2) angle -= Math.PI * 2;
		return angle;
	}
};
/**** 
* Wave System
****/ 
var WaveManager = {
	currentWave: 0,
	totalWaves: 30,
	waveTimer: 0,
	waveDelay: 300,
	// frames between waves
	enemiesPerWave: 15,
	materials: ['slime', 'metal', 'lava', 'ice', 'shadow'],
	update: function update() {
		this.waveTimer--;
		if (this.waveTimer <= 0 && this.currentWave < this.totalWaves) {
			this.spawnWave();
			this.waveTimer = this.waveDelay;
		}
	},
	spawnWave: function spawnWave() {
		this.currentWave++;
		var material = this.materials[(this.currentWave - 1) % this.materials.length];
		var enemyCount = this.enemiesPerWave + Math.floor(this.currentWave / 5);
		for (var i = 0; i < enemyCount; i++) {
			setTimeout(function (mat) {
				return function () {
					var enemy = PoolManager.getEnemy();
					if (enemy) {
						var spawnAngle = Math.random() * Math.PI * 2;
						enemy.activate(mat, spawnAngle);
						gameLayer.addChild(enemy);
					}
				};
			}(material), i * 100); // Stagger spawning
		}
		var notification = new Notification("Wave " + this.currentWave + " - " + material + " blobs!");
		game.addChild(notification);
		notification.x = SCREEN_WIDTH / 2;
		notification.y = 100;
	}
};
/**** 
* Game Constants
****/ 
var SCREEN_WIDTH = 2048;
var SCREEN_HEIGHT = 2732;
var gameLayer = new Container();
var uiLayer = new Container();
var embryo;
var towerSelector;
var gold = 100;
var lives = 20;
var score = 0;
// UI Text Elements
var goldText = new Text2('Gold: ' + gold, {
	size: 48,
	fill: 0xFFD700,
	weight: 800
});
goldText.anchor.set(0.5, 0.5);
var livesText = new Text2('Lives: ' + lives, {
	size: 48,
	fill: 0x00FF00,
	weight: 800
});
livesText.anchor.set(0.5, 0.5);
var scoreText = new Text2('Score: ' + score, {
	size: 48,
	fill: 0xFF0000,
	weight: 800
});
scoreText.anchor.set(0.5, 0.5);
var waveText = new Text2('Wave: 0', {
	size: 48,
	fill: 0x00AAFF,
	weight: 800
});
waveText.anchor.set(0.5, 0.5);
/**** 
* Utility Functions
****/ 
function updateUI() {
	goldText.setText('Gold: ' + gold);
	livesText.setText('Lives: ' + lives);
	scoreText.setText('Score: ' + score);
	waveText.setText('Wave: ' + WaveManager.currentWave);
}
function setGold(value) {
	gold = value;
	updateUI();
}
/**** 
* Game Initialization
****/ 
function initializeGame() {
	// Initialize object pools
	PoolManager.init();
	// Create embryo at center
	embryo = new Embryo();
	embryo.x = SCREEN_WIDTH / 2;
	embryo.y = SCREEN_HEIGHT / 2;
	gameLayer.addChild(embryo);
	// Create tower selector
	towerSelector = new TowerSelector();
	towerSelector.x = SCREEN_WIDTH / 2;
	towerSelector.y = SCREEN_HEIGHT - 150;
	uiLayer.addChild(towerSelector);
	// Position UI elements
	goldText.x = 150;
	goldText.y = 80;
	uiLayer.addChild(goldText);
	livesText.x = 400;
	livesText.y = 80;
	uiLayer.addChild(livesText);
	scoreText.x = 650;
	scoreText.y = 80;
	uiLayer.addChild(scoreText);
	waveText.x = 900;
	waveText.y = 80;
	uiLayer.addChild(waveText);
	// Add layers to game
	game.addChild(gameLayer);
	game.addChild(uiLayer);
	// Start first wave after delay
	WaveManager.waveTimer = 180; // 3 seconds
	updateUI();
}
/**** 
* Camera System
****/ 
var Camera = {
	zoom: 1,
	targetZoom: 1,
	update: function update() {
		// Adjust zoom based on embryo size
		var baseZoom = 1;
		var embryoSize = embryo ? embryo.currentSize : 80;
		this.targetZoom = Math.max(0.6, baseZoom - (embryoSize - 80) / 400);
		// Smooth zoom transition
		this.zoom += (this.targetZoom - this.zoom) * 0.05;
		// Apply zoom to game layer
		gameLayer.scaleX = gameLayer.scaleY = this.zoom;
		// Keep embryo centered
		if (embryo) {
			gameLayer.x = SCREEN_WIDTH / 2 - embryo.x * this.zoom;
			gameLayer.y = SCREEN_HEIGHT / 2 - embryo.y * this.zoom;
		}
	}
};
/**** 
* Game Update Loop
****/ 
game.update = function () {
	// Update all systems
	WaveManager.update();
	Camera.update();
	// Update embryo
	if (embryo) {
		embryo.update();
	}
	// Update all active enemies
	for (var i = 0; i < PoolManager.enemies.length; i++) {
		var enemy = PoolManager.enemies[i];
		if (enemy.active) {
			enemy.update();
		}
	}
	// Update all active bullets
	for (var i = 0; i < PoolManager.bullets.length; i++) {
		var bullet = PoolManager.bullets[i];
		if (bullet.active) {
			bullet.update();
		}
	}
	// Update all active particles
	for (var i = 0; i < PoolManager.particles.length; i++) {
		var particle = PoolManager.particles[i];
		if (particle.active) {
			particle.update();
		}
	}
	// Update all towers
	for (var i = 0; i < embryo.orbitalSlots.length; i++) {
		var slot = embryo.orbitalSlots[i];
		if (slot.tower) {
			slot.tower.update();
		}
	}
	// Check win/lose conditions
	if (lives <= 0) {
		LK.showGameOver();
	} else if (WaveManager.currentWave >= WaveManager.totalWaves) {
		// Check if all enemies are defeated
		var activeEnemies = 0;
		for (var i = 0; i < PoolManager.enemies.length; i++) {
			if (PoolManager.enemies[i].active) {
				activeEnemies++;
			}
		}
		if (activeEnemies === 0) {
			LK.showYouWin();
		}
	}
};
/**** 
* Game Input Handlers
****/ 
game.down = function (x, y, obj) {
	// Handle UI interactions
	// Tower selector handles its own input
};
game.move = function (x, y, obj) {
	// Handle drag interactions if needed
};
game.up = function (x, y, obj) {
	// Handle release interactions if needed
};
/**** 
* Start Game
****/ 
initializeGame();

===================================================================
--- original.js
+++ change.js
@@ -597,14 +597,8 @@
 	self.buttons = [];
 	var buttonWidth = 100;
 	var spacing = 120;
 	var startX = -((self.towerTypes.length - 1) * spacing) / 2;
-	for (var i = 0; i < self.towerTypes.length; i++) {
-		var button = self.createTowerButton(self.towerTypes[i], i);
-		button.x = startX + i * spacing;
-		self.addChild(button);
-		self.buttons.push(button);
-	}
 	self.createTowerButton = function (type, index) {
 		var button = new Container();
 		var bg = button.attachAsset('tower', {
 			anchorX: 0.5,
@@ -684,8 +678,14 @@
 			default:
 				return 15;
 		}
 	};
+	for (var i = 0; i < self.towerTypes.length; i++) {
+		var button = self.createTowerButton(self.towerTypes[i], i);
+		button.x = startX + i * spacing;
+		self.addChild(button);
+		self.buttons.push(button);
+	}
 	return self;
 });
 
 /****