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

/**** 
* Classes
****/ 
var BlobEnemy = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.material = 'slime';
	self.health = 40;
	self.maxHealth = 40;
	self.speed = 1.2;
	self.pathProgress = 0;
	self.waveNumber = 1;
	// Jump states
	self.jumpState = 'paused';
	self.jumpTimer = 0;
	self.pauseDuration = 60;
	self.jumpDuration = 30;
	self.startPosition = {
		x: 0,
		y: 0
	};
	self.targetPosition = {
		x: 0,
		y: 0
	};
	self.jumpDistance = 80;
	self.jumpHeight = 40;
	self.baseY = 0;
	// Status effects
	self.slowed = false;
	self.poisoned = false;
	self.slowDuration = 0;
	self.poisonDuration = 0;
	self.poisonDamage = 0;
	self.originalSpeed = self.speed;
	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, waveNumber) {
		self.active = true;
		self.visible = true;
		self.material = material || 'slime';
		self.waveNumber = waveNumber || 1;
		self.pathProgress = 0;
		self.jumpState = 'paused';
		self.jumpTimer = self.pauseDuration;
		// Reset status effects
		self.slowed = false;
		self.poisoned = false;
		self.slowDuration = 0;
		self.poisonDuration = 0;
		// Set material properties
		self.setMaterial(self.material);
		// Scale health with wave number
		var healthMultiplier = Math.pow(1.15, self.waveNumber);
		self.maxHealth = Math.round(self.maxHealth * healthMultiplier);
		self.health = self.maxHealth;
		// Start at beginning of path
		var startPos = PathSystem.getPositionAlongPath(0);
		self.x = startPos.x;
		self.y = startPos.y;
		self.baseY = self.y;
		// Reset blob scale
		blobGraphics.scaleX = 1;
		blobGraphics.scaleY = 1;
	};
	self.setMaterial = function (material) {
		switch (material) {
			case 'slime':
				blobGraphics.tint = 0x00FF00;
				self.speed = 0.8;
				self.pauseDuration = 60;
				self.jumpDistance = 80;
				self.jumpHeight = 40;
				self.maxHealth = 40;
				break;
			case 'metal':
				blobGraphics.tint = 0xC0C0C0;
				self.speed = 0.6;
				self.pauseDuration = 80;
				self.jumpDistance = 60;
				self.jumpHeight = 25;
				self.maxHealth = 60;
				break;
			case 'lava':
				blobGraphics.tint = 0xFF4500;
				self.speed = 1.0;
				self.pauseDuration = 45;
				self.jumpDistance = 90;
				self.jumpHeight = 50;
				self.maxHealth = 48;
				break;
			case 'ice':
				blobGraphics.tint = 0x87CEEB;
				self.speed = 0.5;
				self.pauseDuration = 90;
				self.jumpDistance = 50;
				self.jumpHeight = 30;
				self.maxHealth = 32;
				break;
			case 'shadow':
				blobGraphics.tint = 0x4B0082;
				self.speed = 1.2;
				self.pauseDuration = 30;
				self.jumpDistance = 100;
				self.jumpHeight = 60;
				self.maxHealth = 80;
				break;
		}
		self.originalSpeed = self.speed;
	};
	self.takeDamage = function (damage, damageType, towerLevel) {
		self.health -= damage;
		healthBar.width = Math.max(0, self.health / self.maxHealth * 70);
		// Apply special effects
		if (damageType === 'splash') {
			var effect = PoolManager.getEffect();
			if (effect) {
				effect.activate(self.x, self.y, 'splash');
				gameLayer.addChild(effect);
			}
		} else if (damageType === 'slow' && self.material !== 'ice') {
			// Ice is immune to slow
			if (!self.slowed) {
				var slowPct = 0.5 + (towerLevel - 1) * 0.05; // 50% to 75% slow
				self.speed = self.originalSpeed * (1 - slowPct);
				self.slowed = true;
				self.slowDuration = 180;
				var effect = PoolManager.getEffect();
				if (effect) {
					effect.activate(self.x, self.y, 'slow');
					gameLayer.addChild(effect);
				}
			} else {
				self.slowDuration = 180; // Reset duration
			}
		} else if (damageType === 'poison' && self.material !== 'metal') {
			// Metal is immune to poison
			if (!self.poisoned) {
				self.poisoned = true;
				self.poisonDamage = damage * 0.2;
				self.poisonDuration = 300;
				var effect = PoolManager.getEffect();
				if (effect) {
					effect.activate(self.x, self.y, 'poison');
					gameLayer.addChild(effect);
				}
			}
		} else if (damageType === 'sniper') {
			var effect = PoolManager.getEffect();
			if (effect) {
				effect.activate(self.x, self.y, 'sniper');
				gameLayer.addChild(effect);
			}
		}
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		// Create death particles
		for (var i = 0; i < 8; i++) {
			var particle = PoolManager.getParticle();
			if (particle) {
				particle.activate(self.x, self.y, self.material);
				gameLayer.addChild(particle);
			}
		}
		// Give gold based on enemy type and wave
		var goldEarned = Math.floor(5 + self.waveNumber * 0.5);
		if (self.material === 'shadow') goldEarned *= 2; // Shadow enemies give double gold
		setGold(gold + goldEarned);
		score += 10 + self.waveNumber;
		PoolManager.returnBlob(self);
	};
	self.startJumpPreparation = function () {
		self.jumpState = 'preparing';
		// Calculate next position along path
		var nextProgress = Math.min(1, self.pathProgress + self.jumpDistance / PathSystem.getPathLength());
		var nextPos = PathSystem.getPositionAlongPath(nextProgress);
		self.startPosition.x = self.x;
		self.startPosition.y = self.baseY;
		self.targetPosition.x = nextPos.x;
		self.targetPosition.y = nextPos.y;
		// Pre-jump compression
		tween.stop(blobGraphics, {
			scaleX: true,
			scaleY: true
		});
		tween(blobGraphics, {
			scaleX: 1.5,
			scaleY: 0.5
		}, {
			duration: 400,
			easing: tween.quadIn,
			onFinish: function onFinish() {
				self.executeJump();
			}
		});
	};
	self.executeJump = function () {
		self.jumpState = 'jumping';
		self.jumpTimer = self.jumpDuration;
		// Stretch animation during jump
		tween.stop(blobGraphics, {
			scaleX: true,
			scaleY: true
		});
		tween(blobGraphics, {
			scaleX: 0.8,
			scaleY: 1.8
		}, {
			duration: self.jumpDuration * 16.67,
			easing: tween.sineInOut
		});
	};
	self.landJump = function () {
		self.jumpState = 'landing';
		self.baseY = self.targetPosition.y;
		// Update path progress
		var pathLength = PathSystem.getPathLength();
		self.pathProgress = Math.min(1, self.pathProgress + self.jumpDistance / pathLength);
		// Landing compression
		tween.stop(blobGraphics, {
			scaleX: true,
			scaleY: true
		});
		tween(blobGraphics, {
			scaleX: 1.4,
			scaleY: 0.6
		}, {
			duration: 200,
			easing: tween.quadOut,
			onFinish: function onFinish() {
				tween(blobGraphics, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 300,
					easing: tween.elasticOut,
					onFinish: function onFinish() {
						self.jumpState = 'paused';
						self.jumpTimer = self.pauseDuration;
					}
				});
			}
		});
	};
	self.getArcPosition = function (progress) {
		var x = self.startPosition.x + (self.targetPosition.x - self.startPosition.x) * progress;
		var startHeight = self.startPosition.y;
		var endHeight = self.targetPosition.y;
		var peakHeight = Math.min(startHeight, endHeight) - self.jumpHeight;
		var arcHeight = peakHeight + 4 * self.jumpHeight * progress * (1 - progress);
		var y = startHeight + (endHeight - startHeight) * progress + (arcHeight - startHeight - (endHeight - startHeight) * progress);
		return {
			x: x,
			y: y
		};
	};
	self.update = function () {
		if (!self.active) return;
		// Handle status effects
		if (self.slowed) {
			self.slowDuration--;
			if (self.slowDuration <= 0) {
				self.speed = self.originalSpeed;
				self.slowed = false;
			}
		}
		if (self.poisoned) {
			if (LK.ticks % 30 === 0) {
				// Poison damage every 30 frames
				self.health -= self.poisonDamage;
				healthBar.width = Math.max(0, self.health / self.maxHealth * 70);
				if (self.health <= 0) {
					self.die();
					return;
				}
			}
			self.poisonDuration--;
			if (self.poisonDuration <= 0) {
				self.poisoned = false;
			}
		}
		// Check if reached end of path
		if (self.pathProgress >= 1) {
			lives--;
			updateUI();
			PoolManager.returnBlob(self);
			if (lives <= 0) {
				LK.showGameOver();
			}
			return;
		}
		// Jump state machine
		switch (self.jumpState) {
			case 'paused':
				self.jumpTimer--;
				if (self.jumpTimer <= 0) {
					self.startJumpPreparation();
				}
				break;
			case 'preparing':
				// Animation handles this
				break;
			case 'jumping':
				self.jumpTimer--;
				var progress = (self.jumpDuration - self.jumpTimer) / self.jumpDuration;
				var arcPos = self.getArcPosition(progress);
				self.x = arcPos.x;
				self.y = arcPos.y;
				if (self.jumpTimer <= 0) {
					self.x = self.targetPosition.x;
					self.y = self.targetPosition.y;
					self.landJump();
				}
				break;
			case 'landing':
				// Animation handles this
				break;
		}
	};
	self.reset = function () {
		self.material = 'slime';
		self.health = 40;
		self.maxHealth = 40;
		self.speed = 1.2;
		self.pathProgress = 0;
		self.waveNumber = 1;
		self.jumpState = 'paused';
		self.jumpTimer = 0;
		self.slowed = false;
		self.poisoned = false;
		self.slowDuration = 0;
		self.poisonDuration = 0;
		tween.stop(blobGraphics);
		blobGraphics.scaleX = 1;
		blobGraphics.scaleY = 1;
		blobGraphics.tint = 0x00FF00;
	};
	return self;
});
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.targetEnemy = null;
	self.damage = 10;
	self.speed = 5;
	self.type = 'default';
	self.sourceTowerLevel = 1;
	var bulletGraphics = self.attachAsset('particle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bulletGraphics.width = 15;
	bulletGraphics.height = 15;
	self.activate = function (startX, startY, targetEnemy, damage, speed, type, sourceTowerLevel) {
		self.active = true;
		self.visible = true;
		self.x = startX;
		self.y = startY;
		self.targetEnemy = targetEnemy;
		self.damage = damage || 10;
		self.speed = speed || 5;
		self.type = type || 'default';
		self.sourceTowerLevel = sourceTowerLevel || 1;
		// Customize appearance based on type
		switch (self.type) {
			case 'rapid':
				bulletGraphics.tint = 0x00AAFF;
				bulletGraphics.width = bulletGraphics.height = 12;
				break;
			case 'sniper':
				bulletGraphics.tint = 0xFF5500;
				bulletGraphics.width = bulletGraphics.height = 8;
				break;
			case 'splash':
				bulletGraphics.tint = 0x33CC00;
				bulletGraphics.width = bulletGraphics.height = 20;
				break;
			case 'slow':
				bulletGraphics.tint = 0x9900FF;
				bulletGraphics.width = bulletGraphics.height = 18;
				break;
			case 'poison':
				bulletGraphics.tint = 0x00FFAA;
				bulletGraphics.width = bulletGraphics.height = 18;
				break;
			default:
				bulletGraphics.tint = 0xFFFFFF;
				bulletGraphics.width = bulletGraphics.height = 15;
		}
	};
	self.update = function () {
		if (!self.active || !self.targetEnemy || !self.targetEnemy.active) {
			PoolManager.returnBullet(self);
			return;
		}
		var dx = self.targetEnemy.x - self.x;
		var dy = self.targetEnemy.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < self.speed) {
			// Hit target
			self.targetEnemy.takeDamage(self.damage, self.type, self.sourceTowerLevel);
			PoolManager.returnBullet(self);
		} else {
			var angle = Math.atan2(dy, dx);
			self.x += Math.cos(angle) * self.speed;
			self.y += Math.sin(angle) * self.speed;
		}
	};
	self.reset = function () {
		self.targetEnemy = null;
		self.damage = 10;
		self.speed = 5;
		self.type = 'default';
		self.sourceTowerLevel = 1;
	};
	return self;
});
var DeathParticle = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.velocity = {
		x: 0,
		y: 0
	};
	self.life = 0;
	self.maxLife = 60;
	var particleGraphics = self.attachAsset('particle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.activate = function (x, y, material) {
		self.active = true;
		self.visible = true;
		self.x = x;
		self.y = y;
		self.life = self.maxLife;
		// Random velocity
		var angle = Math.random() * Math.PI * 2;
		var speed = 2 + Math.random() * 4;
		self.velocity.x = Math.cos(angle) * speed;
		self.velocity.y = 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;
		}
		particleGraphics.width = particleGraphics.height = 4 + Math.random() * 8;
		self.alpha = 1;
	};
	self.update = function () {
		if (!self.active) return;
		self.x += self.velocity.x;
		self.y += self.velocity.y;
		self.velocity.y += 0.2; // Gravity
		self.life--;
		self.alpha = self.life / self.maxLife;
		if (self.life <= 0) {
			PoolManager.returnParticle(self);
		}
	};
	self.reset = function () {
		self.velocity.x = 0;
		self.velocity.y = 0;
		self.life = 0;
	};
	return self;
});
var EffectIndicator = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.effectType = 'splash';
	var effectGraphics = self.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	effectGraphics.blendMode = 1;
	self.activate = function (x, y, type) {
		self.active = true;
		self.visible = true;
		self.x = x;
		self.y = y;
		self.effectType = type;
		switch (type) {
			case 'splash':
				effectGraphics.tint = 0x33CC00;
				effectGraphics.width = effectGraphics.height = CELL_SIZE * 1.5;
				break;
			case 'slow':
				effectGraphics.tint = 0x9900FF;
				effectGraphics.width = effectGraphics.height = CELL_SIZE;
				break;
			case 'poison':
				effectGraphics.tint = 0x00FFAA;
				effectGraphics.width = effectGraphics.height = CELL_SIZE;
				break;
			case 'sniper':
				effectGraphics.tint = 0xFF5500;
				effectGraphics.width = effectGraphics.height = CELL_SIZE;
				break;
		}
		effectGraphics.alpha = 0.7;
		self.alpha = 0;
		self.scaleX = 0.5;
		self.scaleY = 0.5;
		// Animate effect
		tween(self, {
			alpha: 0.8,
			scaleX: 1.5,
			scaleY: 1.5
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(self, {
					alpha: 0,
					scaleX: 2,
					scaleY: 2
				}, {
					duration: 300,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						PoolManager.returnEffect(self);
					}
				});
			}
		});
	};
	self.reset = function () {
		self.effectType = 'splash';
		tween.stop(self);
	};
	return self;
});
var EnergyOrb = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.orbType = 'default';
	self.level = 1;
	self.maxLevel = 6;
	self.gridX = 0;
	self.gridY = 0;
	self.area = 0; // 0 for top area, 1 for bottom area
	self.range = 3 * CELL_SIZE;
	self.damage = 10;
	self.fireRate = 60;
	self.bulletSpeed = 5;
	self.lastFired = 0;
	self.targetEnemy = null;
	self.isDragging = false;
	self.magneticTarget = null;
	var orbGraphics = self.attachAsset('energyOrb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var coreGraphics = self.attachAsset('energyOrb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	coreGraphics.width = 40;
	coreGraphics.height = 40;
	// Level indicators
	var levelIndicators = [];
	for (var i = 0; i < 6; i++) {
		var dot = self.attachAsset('particle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		dot.width = 6;
		dot.height = 6;
		dot.x = (i - 2.5) * 12;
		dot.y = CELL_SIZE * 0.6;
		dot.tint = 0x444444;
		levelIndicators.push(dot);
	}
	self.activate = function (orbType, gridX, gridY, area) {
		self.active = true;
		self.visible = true;
		self.orbType = orbType || 'default';
		self.level = 1;
		self.gridX = gridX;
		self.gridY = gridY;
		self.area = area;
		self.lastFired = 0;
		self.targetEnemy = null;
		self.setOrbType(self.orbType);
		self.updateVisuals();
		self.updatePosition();
	};
	self.setOrbType = function (type) {
		self.orbType = type;
		switch (type) {
			case 'rapid':
				self.fireRate = 30;
				self.damage = 5;
				self.range = 2.5 * CELL_SIZE;
				self.bulletSpeed = 7;
				orbGraphics.tint = coreGraphics.tint = 0x00AAFF;
				break;
			case 'sniper':
				self.fireRate = 90;
				self.damage = 25;
				self.range = 5 * CELL_SIZE;
				self.bulletSpeed = 25;
				orbGraphics.tint = coreGraphics.tint = 0xFF5500;
				break;
			case 'splash':
				self.fireRate = 75;
				self.damage = 15;
				self.range = 2 * CELL_SIZE;
				self.bulletSpeed = 4;
				orbGraphics.tint = coreGraphics.tint = 0x33CC00;
				break;
			case 'slow':
				self.fireRate = 50;
				self.damage = 8;
				self.range = 3.5 * CELL_SIZE;
				self.bulletSpeed = 5;
				orbGraphics.tint = coreGraphics.tint = 0x9900FF;
				break;
			case 'poison':
				self.fireRate = 70;
				self.damage = 12;
				self.range = 3.2 * CELL_SIZE;
				self.bulletSpeed = 5;
				orbGraphics.tint = coreGraphics.tint = 0x00FFAA;
				break;
			default:
				self.fireRate = 60;
				self.damage = 10;
				self.range = 3 * CELL_SIZE;
				self.bulletSpeed = 5;
				orbGraphics.tint = coreGraphics.tint = 0xAAAAAA;
		}
	};
	self.updateVisuals = function () {
		var baseSize = 60 + self.level * 8;
		orbGraphics.width = orbGraphics.height = baseSize;
		var coreSize = 30 + self.level * 4;
		coreGraphics.width = coreGraphics.height = coreSize;
		// Update level indicators
		for (var i = 0; i < levelIndicators.length; i++) {
			if (i < self.level) {
				levelIndicators[i].tint = 0xFFFFFF;
				levelIndicators[i].alpha = 1;
			} else {
				levelIndicators[i].tint = 0x444444;
				levelIndicators[i].alpha = 0.5;
			}
		}
		// Pulsing animation based on level
		var pulseScale = 1 + self.level * 0.02;
		tween.stop(orbGraphics, {
			scaleX: true,
			scaleY: true
		});
		tween(orbGraphics, {
			scaleX: pulseScale,
			scaleY: pulseScale
		}, {
			duration: 1000 + self.level * 200,
			easing: tween.sineInOut,
			repeat: -1,
			yoyo: true
		});
	};
	self.updatePosition = function () {
		var startX = self.area === 0 ? TOP_AREA_X : BOTTOM_AREA_X;
		var startY = self.area === 0 ? TOP_AREA_Y : BOTTOM_AREA_Y;
		self.x = startX + self.gridX * CELL_SIZE + CELL_SIZE / 2;
		self.y = startY + self.gridY * CELL_SIZE + CELL_SIZE / 2;
	};
	self.getRange = function () {
		var baseRange = self.range;
		var rangeMultiplier = 1 + (self.level - 1) * 0.15;
		if (self.orbType === 'sniper' && self.level === self.maxLevel) {
			rangeMultiplier *= 2; // Max level sniper gets huge range boost
		}
		return baseRange * rangeMultiplier;
	};
	self.getCurrentDamage = function () {
		var damageMultiplier = 1 + (self.level - 1) * 0.5;
		if (self.level === self.maxLevel) {
			damageMultiplier *= 2; // Max level gets double damage bonus
		}
		return Math.floor(self.damage * damageMultiplier);
	};
	self.getCurrentFireRate = function () {
		var rateMultiplier = 1 + (self.level - 1) * 0.3;
		return Math.max(10, Math.floor(self.fireRate / rateMultiplier));
	};
	self.findTarget = function () {
		var closestEnemy = null;
		var closestDistance = Infinity;
		var orbRange = self.getRange();
		for (var i = 0; i < activeBlobs.length; i++) {
			var blob = activeBlobs[i];
			if (!blob.active) continue;
			var dx = blob.x - self.x;
			var dy = blob.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= orbRange && distance < closestDistance) {
				closestDistance = distance;
				closestEnemy = blob;
			}
		}
		return closestEnemy;
	};
	self.fire = function () {
		if (!self.targetEnemy) return;
		var bullet = PoolManager.getBullet();
		if (bullet) {
			var bulletStartX = self.x + Math.cos(coreGraphics.rotation) * 30;
			var bulletStartY = self.y + Math.sin(coreGraphics.rotation) * 30;
			bullet.activate(bulletStartX, bulletStartY, self.targetEnemy, self.getCurrentDamage(), self.bulletSpeed + self.level, self.orbType, self.level);
			gameLayer.addChild(bullet);
			activeBullets.push(bullet);
			// Recoil effect
			tween.stop(coreGraphics, {
				scaleX: true,
				scaleY: true
			});
			tween(coreGraphics, {
				scaleX: 0.8,
				scaleY: 0.8
			}, {
				duration: 100,
				easing: tween.quadOut,
				onFinish: function onFinish() {
					tween(coreGraphics, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 150,
						easing: tween.elasticOut
					});
				}
			});
		}
	};
	self.canMergeWith = function (otherOrb) {
		return otherOrb && otherOrb !== self && otherOrb.active && otherOrb.orbType === self.orbType && otherOrb.level === self.level && self.level < self.maxLevel;
	};
	self.checkMagneticAttraction = function (otherOrb) {
		if (!self.canMergeWith(otherOrb)) {
			self.magneticTarget = null;
			return;
		}
		var dx = otherOrb.x - self.x;
		var dy = otherOrb.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < CELL_SIZE * 1.5) {
			self.magneticTarget = otherOrb;
			// Subtle attraction animation
			tween.stop(self, {
				x: true,
				y: true
			});
			tween(self, {
				x: self.x + dx * 0.1,
				y: self.y + dy * 0.1
			}, {
				duration: 100,
				easing: tween.quadOut
			});
		} else {
			self.magneticTarget = null;
		}
	};
	self.mergeWith = function (otherOrb, targetArea) {
		if (!self.canMergeWith(otherOrb)) return false;
		// Find empty spot in target area
		var emptySpot = GameManager.findEmptySpot(targetArea);
		if (!emptySpot) {
			// Target area is full, merge stays in current area
			emptySpot = GameManager.findEmptySpot(self.area);
			if (!emptySpot) return false;
			targetArea = self.area;
		}
		// Create new merged orb
		var newOrb = PoolManager.getEnergyOrb();
		if (newOrb) {
			newOrb.activate(self.orbType, emptySpot.x, emptySpot.y, targetArea);
			newOrb.level = self.level + 1;
			newOrb.updateVisuals();
			if (targetArea === 0) {
				topAreaLayer.addChild(newOrb);
				topAreaOrbs[emptySpot.x][emptySpot.y] = newOrb;
			} else {
				bottomAreaLayer.addChild(newOrb);
				bottomAreaOrbs[emptySpot.x][emptySpot.y] = newOrb;
			}
			// Merge animation
			tween(newOrb, {
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 200,
				easing: tween.elasticOut,
				onFinish: function onFinish() {
					tween(newOrb, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 300,
						easing: tween.elasticOut
					});
				}
			});
			// Remove old orbs
			GameManager.removeOrb(self);
			GameManager.removeOrb(otherOrb);
			return true;
		}
		return false;
	};
	self.update = function () {
		if (!self.active) return;
		// Find and track target
		self.targetEnemy = self.findTarget();
		if (self.targetEnemy) {
			// Rotate core towards target
			var dx = self.targetEnemy.x - self.x;
			var dy = self.targetEnemy.y - self.y;
			var angle = Math.atan2(dy, dx);
			tween.stop(coreGraphics, {
				rotation: true
			});
			tween(coreGraphics, {
				rotation: angle
			}, {
				duration: 200,
				easing: tween.quadOut
			});
			// Fire at target
			if (LK.ticks - self.lastFired >= self.getCurrentFireRate()) {
				self.fire();
				self.lastFired = LK.ticks;
			}
		}
	};
	self.reset = function () {
		self.orbType = 'default';
		self.level = 1;
		self.gridX = 0;
		self.gridY = 0;
		self.area = 0;
		self.lastFired = 0;
		self.targetEnemy = null;
		self.isDragging = false;
		self.magneticTarget = null;
		tween.stop(self);
		tween.stop(orbGraphics);
		tween.stop(coreGraphics);
		orbGraphics.scaleX = orbGraphics.scaleY = 1;
		coreGraphics.scaleX = coreGraphics.scaleY = 1;
		coreGraphics.rotation = 0;
	};
	return self;
});
var GenerateButton = Container.expand(function (area) {
	var self = Container.call(this);
	self.area = area; // 0 for top, 1 for bottom
	self.cost = 10;
	var buttonGraphics = self.attachAsset('generateButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var costText = new Text2('Generate: ' + self.cost, {
		size: 30,
		fill: 0xFFFFFF,
		weight: 800
	});
	costText.anchor.set(0.5, 0.5);
	self.addChild(costText);
	self.updateCost = function () {
		// Fibonacci-like progression
		var newCost = Math.floor(10 * Math.pow(1.618, GameManager.getGenerateCount(self.area)));
		self.cost = newCost;
		costText.setText('Generate: ' + self.cost);
		// Update button color based on affordability
		if (gold >= self.cost) {
			buttonGraphics.tint = 0x00AA00;
		} else {
			buttonGraphics.tint = 0x888888;
		}
	};
	self.generate = function () {
		if (gold < self.cost) return false;
		var emptySpot = GameManager.findEmptySpot(self.area);
		if (!emptySpot) return false;
		// Random tower type
		var types = ['default', 'rapid', 'sniper', 'splash', 'slow', 'poison'];
		var randomType = types[Math.floor(Math.random() * types.length)];
		var newOrb = PoolManager.getEnergyOrb();
		if (newOrb) {
			newOrb.activate(randomType, emptySpot.x, emptySpot.y, self.area);
			if (self.area === 0) {
				topAreaLayer.addChild(newOrb);
				topAreaOrbs[emptySpot.x][emptySpot.y] = newOrb;
			} else {
				bottomAreaLayer.addChild(newOrb);
				bottomAreaOrbs[emptySpot.x][emptySpot.y] = newOrb;
			}
			setGold(gold - self.cost);
			GameManager.incrementGenerateCount(self.area);
			self.updateCost();
			// Spawn animation
			newOrb.alpha = 0;
			newOrb.scaleX = newOrb.scaleY = 0.5;
			tween(newOrb, {
				alpha: 1,
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 300,
				easing: tween.elasticOut
			});
			return true;
		}
		return false;
	};
	self.down = function () {
		self.generate();
	};
	self.update = function () {
		self.updateCost();
	};
	return self;
});
var Notification = Container.expand(function (message) {
	var self = Container.call(this);
	var notificationGraphics = self.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var notificationText = new Text2(message, {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	notificationText.anchor.set(0.5, 0.5);
	notificationGraphics.width = notificationText.width + 30;
	self.addChild(notificationText);
	self.alpha = 1;
	var fadeOutTime = 180; // 3 seconds
	self.update = function () {
		if (fadeOutTime > 0) {
			fadeOutTime--;
			self.alpha = Math.min(fadeOutTime / 60, 1);
		} else {
			self.destroy();
		}
	};
	return self;
});
/**** 
* Game Manager
****/ 
var WaveManager = Container.expand(function () {
	var self = Container.call(this);
	self.currentWave = 0;
	self.maxWaves = 50;
	self.waveTimer = 0;
	self.waveDelay = 300; // 5 seconds at 60fps
	self.waveActive = false;
	self.enemiesSpawned = 0;
	self.enemiesToSpawn = 0;
	self.spawnTimer = 0;
	self.spawnDelay = 30; // 0.5 seconds between spawns
	var waveText = new Text2('Wave: 1', {
		size: 60,
		fill: 0xFFFF00,
		weight: 800
	});
	waveText.anchor.set(0.5, 0.5);
	self.addChild(waveText);
	self.startNextWave = function () {
		self.currentWave++;
		self.waveActive = true;
		self.enemiesSpawned = 0;
		self.spawnTimer = 0;
		// Determine wave composition
		self.enemiesToSpawn = 10 + Math.floor(self.currentWave * 1.5);
		waveText.setText('Wave: ' + self.currentWave);
		// Show wave start notification
		var notification = new Notification('Wave ' + self.currentWave + ' incoming!');
		notification.x = SCREEN_WIDTH / 2;
		notification.y = SCREEN_HEIGHT / 2;
		gameLayer.addChild(notification);
	};
	self.getWaveMaterial = function () {
		// Introduce new materials over time
		if (self.currentWave <= 5) return 'slime';
		if (self.currentWave <= 10) return Math.random() < 0.7 ? 'slime' : 'metal';
		if (self.currentWave <= 15) {
			var materials = ['slime', 'metal', 'ice'];
			return materials[Math.floor(Math.random() * materials.length)];
		}
		if (self.currentWave <= 25) {
			var materials = ['slime', 'metal', 'ice', 'lava'];
			return materials[Math.floor(Math.random() * materials.length)];
		}
		// All materials available
		var materials = ['slime', 'metal', 'ice', 'lava', 'shadow'];
		return materials[Math.floor(Math.random() * materials.length)];
	};
	self.spawnEnemy = function () {
		var blob = PoolManager.getBlob();
		if (blob) {
			var material = self.getWaveMaterial();
			blob.activate(material, self.currentWave);
			gameLayer.addChild(blob);
			activeBlobs.push(blob);
			self.enemiesSpawned++;
		}
	};
	self.update = function () {
		if (!self.waveActive) {
			self.waveTimer++;
			if (self.waveTimer >= self.waveDelay) {
				self.waveTimer = 0;
				self.startNextWave();
			}
		} else {
			// Spawn enemies
			if (self.enemiesSpawned < self.enemiesToSpawn) {
				self.spawnTimer++;
				if (self.spawnTimer >= self.spawnDelay) {
					self.spawnTimer = 0;
					self.spawnEnemy();
				}
			} else {
				// Check if wave is complete
				var activeEnemies = 0;
				for (var i = 0; i < activeBlobs.length; i++) {
					if (activeBlobs[i].active) activeEnemies++;
				}
				if (activeEnemies === 0) {
					self.waveActive = false;
					if (self.currentWave >= self.maxWaves) {
						LK.showYouWin();
					}
				}
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
/**** 
* Object Pools
****/ 
/**** 
* Game Constants
****/ 
var PoolManager = {
	energyOrbPool: [],
	blobPool: [],
	bulletPool: [],
	particlePool: [],
	effectPool: [],
	// Pool sizes
	ENERGY_ORB_POOL_SIZE: 30,
	BLOB_POOL_SIZE: 100,
	BULLET_POOL_SIZE: 200,
	PARTICLE_POOL_SIZE: 500,
	EFFECT_POOL_SIZE: 100,
	init: function init() {
		// Initialize energy orb pool
		for (var i = 0; i < this.ENERGY_ORB_POOL_SIZE; i++) {
			var orb = new EnergyOrb();
			orb.active = false;
			orb.visible = false;
			this.energyOrbPool.push(orb);
		}
		// Initialize blob pool
		for (var i = 0; i < this.BLOB_POOL_SIZE; i++) {
			var blob = new BlobEnemy();
			blob.active = false;
			blob.visible = false;
			this.blobPool.push(blob);
		}
		// Initialize bullet pool
		for (var i = 0; i < this.BULLET_POOL_SIZE; i++) {
			var bullet = new Bullet();
			bullet.active = false;
			bullet.visible = false;
			this.bulletPool.push(bullet);
		}
		// Initialize particle pool
		for (var i = 0; i < this.PARTICLE_POOL_SIZE; i++) {
			var particle = new DeathParticle();
			particle.active = false;
			particle.visible = false;
			this.particlePool.push(particle);
		}
		// Initialize effect pool
		for (var i = 0; i < this.EFFECT_POOL_SIZE; i++) {
			var effect = new EffectIndicator();
			effect.active = false;
			effect.visible = false;
			this.effectPool.push(effect);
		}
	},
	getEnergyOrb: function getEnergyOrb() {
		for (var i = 0; i < this.energyOrbPool.length; i++) {
			if (!this.energyOrbPool[i].active) {
				return this.energyOrbPool[i];
			}
		}
		return null; // Pool exhausted
	},
	getBlob: function getBlob() {
		for (var i = 0; i < this.blobPool.length; i++) {
			if (!this.blobPool[i].active) {
				return this.blobPool[i];
			}
		}
		return null;
	},
	getBullet: function getBullet() {
		for (var i = 0; i < this.bulletPool.length; i++) {
			if (!this.bulletPool[i].active) {
				return this.bulletPool[i];
			}
		}
		return null;
	},
	getParticle: function getParticle() {
		for (var i = 0; i < this.particlePool.length; i++) {
			if (!this.particlePool[i].active) {
				return this.particlePool[i];
			}
		}
		return null;
	},
	getEffect: function getEffect() {
		for (var i = 0; i < this.effectPool.length; i++) {
			if (!this.effectPool[i].active) {
				return this.effectPool[i];
			}
		}
		return null;
	},
	returnEnergyOrb: function returnEnergyOrb(orb) {
		orb.active = false;
		orb.visible = false;
		orb.reset();
	},
	returnBlob: function returnBlob(blob) {
		blob.active = false;
		blob.visible = false;
		blob.reset();
		if (blob.shadow) {
			blob.shadow.visible = false;
		}
	},
	returnBullet: function returnBullet(bullet) {
		bullet.active = false;
		bullet.visible = false;
		bullet.reset();
	},
	returnParticle: function returnParticle(particle) {
		particle.active = false;
		particle.visible = false;
		particle.reset();
	},
	returnEffect: function returnEffect(effect) {
		effect.active = false;
		effect.visible = false;
		effect.reset();
	}
};
/**** 
* Path System - WRAPPED AROUND BUILDING AREAS
****/ 
var PathSystem = {
	pathPoints: [],
	init: function init() {
		// Use much more of the screen for the path
		var pathLeft = 150; // Start near left edge of screen
		var pathRight = SCREEN_WIDTH - 150; // Go to near right edge of screen
		var pathTop = 400; // Start below UI
		var pathMiddle = TOP_AREA_Y + BUILDING_AREA_HEIGHT + 370; // Center path in the new 740px gap
		var pathBottom = BOTTOM_AREA_Y + BUILDING_AREA_HEIGHT + 100; // Position path 100px below the build area
		this.pathPoints = [
		// Start from top-left of screen
		{
			x: pathLeft,
			y: pathTop
		},
		// Across top of screen
		{
			x: pathRight,
			y: pathTop
		},
		// Down right side to middle
		{
			x: pathRight,
			y: pathMiddle
		},
		// Across middle (between building areas) to left
		{
			x: pathLeft,
			y: pathMiddle
		},
		// Down left side to bottom
		{
			x: pathLeft,
			y: pathBottom
		},
		// Across bottom to exit at right
		{
			x: pathRight,
			y: pathBottom
		}];
	},
	getPositionAlongPath: function getPositionAlongPath(progress) {
		if (progress <= 0) return {
			x: this.pathPoints[0].x,
			y: this.pathPoints[0].y
		};
		if (progress >= 1) return {
			x: this.pathPoints[this.pathPoints.length - 1].x,
			y: this.pathPoints[this.pathPoints.length - 1].y
		};
		var totalSegments = this.pathPoints.length - 1;
		var segmentProgress = progress * totalSegments;
		var currentSegment = Math.floor(segmentProgress);
		var segmentRatio = segmentProgress - currentSegment;
		if (currentSegment >= totalSegments) {
			return {
				x: this.pathPoints[this.pathPoints.length - 1].x,
				y: this.pathPoints[this.pathPoints.length - 1].y
			};
		}
		var start = this.pathPoints[currentSegment];
		var end = this.pathPoints[currentSegment + 1];
		return {
			x: start.x + (end.x - start.x) * segmentRatio,
			y: start.y + (end.y - start.y) * segmentRatio
		};
	},
	getPathLength: function getPathLength() {
		var totalLength = 0;
		for (var i = 0; i < this.pathPoints.length - 1; i++) {
			var dx = this.pathPoints[i + 1].x - this.pathPoints[i].x;
			var dy = this.pathPoints[i + 1].y - this.pathPoints[i].y;
			totalLength += Math.sqrt(dx * dx + dy * dy);
		}
		return totalLength;
	}
};
/**** 
* Game Manager
****/ 
var GameManager = {
	topAreaGenerateCount: 0,
	bottomAreaGenerateCount: 0,
	findEmptySpot: function findEmptySpot(area) {
		var orbs = area === 0 ? topAreaOrbs : bottomAreaOrbs;
		for (var y = 0; y < GRID_ROWS; y++) {
			for (var x = 0; x < GRID_COLS; x++) {
				if (!orbs[x][y]) {
					return {
						x: x,
						y: y
					};
				}
			}
		}
		return null;
	},
	removeOrb: function removeOrb(orb) {
		var orbs = orb.area === 0 ? topAreaOrbs : bottomAreaOrbs;
		var layer = orb.area === 0 ? topAreaLayer : bottomAreaLayer;
		orbs[orb.gridX][orb.gridY] = null;
		layer.removeChild(orb);
		PoolManager.returnEnergyOrb(orb);
	},
	getOrbAt: function getOrbAt(area, gridX, gridY) {
		var orbs = area === 0 ? topAreaOrbs : bottomAreaOrbs;
		return orbs[gridX] && orbs[gridX][gridY];
	},
	getGenerateCount: function getGenerateCount(area) {
		return area === 0 ? this.topAreaGenerateCount : this.bottomAreaGenerateCount;
	},
	incrementGenerateCount: function incrementGenerateCount(area) {
		if (area === 0) {
			this.topAreaGenerateCount++;
		} else {
			this.bottomAreaGenerateCount++;
		}
	}
};
/**** 
* Game Constants - ACTUALLY USE THE FULL SCREEN
****/ 
var CELL_SIZE = 120; // Bigger cells for better visibility
var GRID_COLS = 5;
var GRID_ROWS = 4;
var SCREEN_WIDTH = 2048;
var SCREEN_HEIGHT = 2732;
// Actually use the full screen dimensions
var BUILDING_AREA_WIDTH = GRID_COLS * CELL_SIZE; // 600px wide
var BUILDING_AREA_HEIGHT = GRID_ROWS * CELL_SIZE; // 480px tall
// Center the building areas in the screen with proper spacing
var TOP_AREA_X = (SCREEN_WIDTH - BUILDING_AREA_WIDTH) / 2; // ~724px from left
var TOP_AREA_Y = 500; // Start well below UI
var BOTTOM_AREA_X = TOP_AREA_X; // Same X position
var BOTTOM_AREA_Y = TOP_AREA_Y + BUILDING_AREA_HEIGHT + 740; // Increased to 740px gap between areas
// Path uses much more of the screen
var PATH_MARGIN = 200; // Bigger margins for wider paths
/**** 
* Game Variables
****/ 
var gold = 100;
var lives = 20;
var score = 0;
var activeBlobs = [];
var activeBullets = [];
var topAreaOrbs = [];
var bottomAreaOrbs = [];
var selectedOrb = null;
var isDragging = false;
var dragStartPos = {
	x: 0,
	y: 0
};
/**** 
* Initialize Arrays
****/ 
for (var x = 0; x < GRID_COLS; x++) {
	topAreaOrbs[x] = [];
	bottomAreaOrbs[x] = [];
	for (var y = 0; y < GRID_ROWS; y++) {
		topAreaOrbs[x][y] = null;
		bottomAreaOrbs[x][y] = null;
	}
}
/**** 
* UI Elements
****/ 
var goldText = new Text2('Gold: ' + gold, {
	size: 60,
	fill: 0xFFD700,
	weight: 800
});
goldText.anchor.set(0.5, 0.5);
var livesText = new Text2('Lives: ' + lives, {
	size: 60,
	fill: 0x00FF00,
	weight: 800
});
livesText.anchor.set(0.5, 0.5);
var scoreText = new Text2('Score: ' + score, {
	size: 60,
	fill: 0xFF0000,
	weight: 800
});
scoreText.anchor.set(0.5, 0.5);
LK.gui.top.addChild(goldText);
LK.gui.top.addChild(livesText);
LK.gui.top.addChild(scoreText);
goldText.x = -400;
goldText.y = 50;
livesText.x = 0;
livesText.y = 50;
scoreText.x = 400;
scoreText.y = 50;
function updateUI() {
	goldText.setText('Gold: ' + gold);
	livesText.setText('Lives: ' + lives);
	scoreText.setText('Score: ' + score);
}
function setGold(value) {
	gold = value;
	updateUI();
}
/**** 
* Layer Setup
****/ 
var gameLayer = new Container();
var topAreaLayer = new Container();
var bottomAreaLayer = new Container();
var effectLayer = new Container();
game.addChild(gameLayer);
game.addChild(topAreaLayer);
game.addChild(bottomAreaLayer);
game.addChild(effectLayer);
/**** 
* Generate Buttons - PROPERLY POSITIONED
****/ 
var topGenerateButton = new GenerateButton(0);
topGenerateButton.x = TOP_AREA_X + BUILDING_AREA_WIDTH + 100;
topGenerateButton.y = TOP_AREA_Y + BUILDING_AREA_HEIGHT / 2;
game.addChild(topGenerateButton);
var bottomGenerateButton = new GenerateButton(1);
bottomGenerateButton.x = BOTTOM_AREA_X + BUILDING_AREA_WIDTH + 100;
bottomGenerateButton.y = BOTTOM_AREA_Y + BUILDING_AREA_HEIGHT / 2;
game.addChild(bottomGenerateButton);
/**** 
* Wave Manager - BOTTOM OF SCREEN
****/ 
var waveManager = new WaveManager();
waveManager.x = SCREEN_WIDTH / 2;
waveManager.y = SCREEN_HEIGHT - 200; // Actually near bottom of screen
game.addChild(waveManager);
/**** 
* Input Handling
****/ 
game.down = function (x, y, obj) {
	// Check if clicking on an orb
	var clickedOrb = null;
	var clickedArea = -1;
	// Check top area
	if (x >= TOP_AREA_X && x <= TOP_AREA_X + GRID_COLS * CELL_SIZE && y >= TOP_AREA_Y && y <= TOP_AREA_Y + GRID_ROWS * CELL_SIZE) {
		var gridX = Math.floor((x - TOP_AREA_X) / CELL_SIZE);
		var gridY = Math.floor((y - TOP_AREA_Y) / CELL_SIZE);
		clickedOrb = GameManager.getOrbAt(0, gridX, gridY);
		clickedArea = 0;
	}
	// Check bottom area
	if (!clickedOrb && x >= BOTTOM_AREA_X && x <= BOTTOM_AREA_X + GRID_COLS * CELL_SIZE && y >= BOTTOM_AREA_Y && y <= BOTTOM_AREA_Y + GRID_ROWS * CELL_SIZE) {
		var gridX = Math.floor((x - BOTTOM_AREA_X) / CELL_SIZE);
		var gridY = Math.floor((y - BOTTOM_AREA_Y) / CELL_SIZE);
		clickedOrb = GameManager.getOrbAt(1, gridX, gridY);
		clickedArea = 1;
	}
	if (clickedOrb) {
		selectedOrb = clickedOrb;
		isDragging = true;
		dragStartPos.x = x;
		dragStartPos.y = y;
		selectedOrb.isDragging = true;
		// Bring to front
		var layer = selectedOrb.area === 0 ? topAreaLayer : bottomAreaLayer;
		layer.removeChild(selectedOrb);
		layer.addChild(selectedOrb);
	}
};
game.move = function (x, y, obj) {
	if (isDragging && selectedOrb) {
		selectedOrb.x = selectedOrb.x + (x - dragStartPos.x);
		selectedOrb.y = selectedOrb.y + (y - dragStartPos.y);
		dragStartPos.x = x;
		dragStartPos.y = y;
		// Check for magnetic attraction
		var orbs = selectedOrb.area === 0 ? topAreaOrbs : bottomAreaOrbs;
		for (var gx = 0; gx < GRID_COLS; gx++) {
			for (var gy = 0; gy < GRID_ROWS; gy++) {
				var otherOrb = orbs[gx][gy];
				if (otherOrb && otherOrb !== selectedOrb) {
					selectedOrb.checkMagneticAttraction(otherOrb);
				}
			}
		}
	}
};
game.up = function (x, y, obj) {
	if (isDragging && selectedOrb) {
		isDragging = false;
		selectedOrb.isDragging = false;
		// Check for merge
		var mergeHappened = false;
		var targetArea = -1;
		// Determine which area we're over
		if (x >= TOP_AREA_X && x <= TOP_AREA_X + GRID_COLS * CELL_SIZE && y >= TOP_AREA_Y && y <= TOP_AREA_Y + GRID_ROWS * CELL_SIZE) {
			targetArea = 0;
		} else if (x >= BOTTOM_AREA_X && x <= BOTTOM_AREA_X + GRID_COLS * CELL_SIZE && y >= BOTTOM_AREA_Y && y <= BOTTOM_AREA_Y + GRID_ROWS * CELL_SIZE) {
			targetArea = 1;
		}
		if (targetArea !== -1) {
			var gridX = Math.floor((x - (targetArea === 0 ? TOP_AREA_X : BOTTOM_AREA_X)) / CELL_SIZE);
			var gridY = Math.floor((y - (targetArea === 0 ? TOP_AREA_Y : BOTTOM_AREA_Y)) / CELL_SIZE);
			if (gridX >= 0 && gridX < GRID_COLS && gridY >= 0 && gridY < GRID_ROWS) {
				var targetOrb = GameManager.getOrbAt(targetArea, gridX, gridY);
				if (targetOrb && selectedOrb.canMergeWith(targetOrb)) {
					// Merge the orbs
					var otherArea = targetArea === 0 ? 1 : 0;
					mergeHappened = selectedOrb.mergeWith(targetOrb, otherArea);
				}
			}
		}
		if (!mergeHappened) {
			// Return orb to original position
			selectedOrb.updatePosition();
			// Smooth return animation
			tween(selectedOrb, {
				x: selectedOrb.area === 0 ? TOP_AREA_X + selectedOrb.gridX * CELL_SIZE + CELL_SIZE / 2 : BOTTOM_AREA_X + selectedOrb.gridX * CELL_SIZE + CELL_SIZE / 2,
				y: selectedOrb.area === 0 ? TOP_AREA_Y + selectedOrb.gridY * CELL_SIZE + CELL_SIZE / 2 : BOTTOM_AREA_Y + selectedOrb.gridY * CELL_SIZE + CELL_SIZE / 2
			}, {
				duration: 300,
				easing: tween.elasticOut
			});
		}
		selectedOrb.magneticTarget = null;
		selectedOrb = null;
	}
};
/**** 
* Grid Visual Indicators
****/ 
function drawGridLines() {
	// Top area grid
	for (var x = 0; x <= GRID_COLS; x++) {
		var line = new Container();
		var lineGraphics = line.attachAsset('cell', {
			anchorX: 0,
			anchorY: 0
		});
		lineGraphics.width = 2;
		lineGraphics.height = GRID_ROWS * CELL_SIZE;
		lineGraphics.tint = 0x444444;
		lineGraphics.alpha = 0.3;
		line.x = TOP_AREA_X + x * CELL_SIZE;
		line.y = TOP_AREA_Y;
		gameLayer.addChild(line);
	}
	for (var y = 0; y <= GRID_ROWS; y++) {
		var line = new Container();
		var lineGraphics = line.attachAsset('cell', {
			anchorX: 0,
			anchorY: 0
		});
		lineGraphics.width = GRID_COLS * CELL_SIZE;
		lineGraphics.height = 2;
		lineGraphics.tint = 0x444444;
		lineGraphics.alpha = 0.3;
		line.x = TOP_AREA_X;
		line.y = TOP_AREA_Y + y * CELL_SIZE;
		gameLayer.addChild(line);
	}
	// Bottom area grid
	for (var x = 0; x <= GRID_COLS; x++) {
		var line = new Container();
		var lineGraphics = line.attachAsset('cell', {
			anchorX: 0,
			anchorY: 0
		});
		lineGraphics.width = 2;
		lineGraphics.height = GRID_ROWS * CELL_SIZE;
		lineGraphics.tint = 0x444444;
		lineGraphics.alpha = 0.3;
		line.x = BOTTOM_AREA_X + x * CELL_SIZE;
		line.y = BOTTOM_AREA_Y;
		gameLayer.addChild(line);
	}
	for (var y = 0; y <= GRID_ROWS; y++) {
		var line = new Container();
		var lineGraphics = line.attachAsset('cell', {
			anchorX: 0,
			anchorY: 0
		});
		lineGraphics.width = GRID_COLS * CELL_SIZE;
		lineGraphics.height = 2;
		lineGraphics.tint = 0x444444;
		lineGraphics.alpha = 0.3;
		line.x = BOTTOM_AREA_X;
		line.y = BOTTOM_AREA_Y + y * CELL_SIZE;
		gameLayer.addChild(line);
	}
}
/**** 
* Path Visualization
****/ 
function drawPath() {
	for (var i = 0; i < PathSystem.pathPoints.length - 1; i++) {
		var start = PathSystem.pathPoints[i];
		var end = PathSystem.pathPoints[i + 1];
		var dx = end.x - start.x;
		var dy = end.y - start.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		var segments = Math.floor(distance / 20);
		for (var j = 0; j < segments; j++) {
			var progress = j / segments;
			var x = start.x + dx * progress;
			var y = start.y + dy * progress;
			var pathDot = new Container();
			var dotGraphics = pathDot.attachAsset('particle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			dotGraphics.width = dotGraphics.height = 8;
			dotGraphics.tint = 0x666666;
			dotGraphics.alpha = 0.6;
			pathDot.x = x;
			pathDot.y = y;
			gameLayer.addChild(pathDot);
		}
	}
}
/**** 
* Initialization
****/ 
PoolManager.init();
PathSystem.init();
drawGridLines();
drawPath();
// Start first wave after a delay
waveManager.waveTimer = 240; // 4 second delay before first wave
/**** 
* Main Game Loop
****/ 
game.update = function () {
	// Update active blobs
	for (var i = activeBlobs.length - 1; i >= 0; i--) {
		var blob = activeBlobs[i];
		if (blob.active) {
			blob.update();
		} else {
			activeBlobs.splice(i, 1);
			gameLayer.removeChild(blob);
		}
	}
	// Update active bullets
	for (var i = activeBullets.length - 1; i >= 0; i--) {
		var bullet = activeBullets[i];
		if (bullet.active) {
			bullet.update();
		} else {
			activeBullets.splice(i, 1);
			gameLayer.removeChild(bullet);
		}
	}
	// Update all orbs
	for (var x = 0; x < GRID_COLS; x++) {
		for (var y = 0; y < GRID_ROWS; y++) {
			if (topAreaOrbs[x][y]) {
				topAreaOrbs[x][y].update();
			}
			if (bottomAreaOrbs[x][y]) {
				bottomAreaOrbs[x][y].update();
			}
		}
	}
	// Update active particles
	var allParticles = gameLayer.children.filter(function (child) {
		return child instanceof DeathParticle;
	});
	for (var i = 0; i < allParticles.length; i++) {
		allParticles[i].update();
	}
	// Update active effects
	var allEffects = gameLayer.children.filter(function (child) {
		return child instanceof EffectIndicator;
	});
	for (var i = 0; i < allEffects.length; i++) {
		if (allEffects[i] && typeof allEffects[i].update === 'function') {
			allEffects[i].update();
		}
	}
	// Update notifications
	var allNotifications = gameLayer.children.filter(function (child) {
		return child instanceof Notification;
	});
	for (var i = 0; i < allNotifications.length; i++) {
		allNotifications[i].update();
	}
	// Update wave manager
	waveManager.update();
	// Update generate buttons
	topGenerateButton.update();
	bottomGenerateButton.update();
	// Check win condition
	if (waveManager.currentWave >= waveManager.maxWaves && activeBlobs.length === 0) {
		LK.showYouWin();
	}
	// Check lose condition
	if (lives <= 0) {
		LK.showGameOver();
	}
	updateUI();
};
/**** 
* Debug Features (Remove in production)
****/ 
if (LK.debug) {
	// Add some starting orbs for testing
	setTimeout(function () {
		var testOrb1 = PoolManager.getEnergyOrb();
		if (testOrb1) {
			testOrb1.activate('rapid', 1, 1, 0);
			topAreaLayer.addChild(testOrb1);
			topAreaOrbs[1][1] = testOrb1;
		}
		var testOrb2 = PoolManager.getEnergyOrb();
		if (testOrb2) {
			testOrb2.activate('sniper', 1, 3, 1);
			bottomAreaLayer.addChild(testOrb2);
			bottomAreaOrbs[1][3] = testOrb2;
		}
	}, 1000);
}
/**** 
* Performance Monitoring (Optional)
****/ 
var PerformanceMonitor = {
	frameCount: 0,
	lastTime: Date.now(),
	fps: 60,
	update: function update() {
		this.frameCount++;
		var currentTime = Date.now();
		if (currentTime - this.lastTime >= 1000) {
			this.fps = this.frameCount;
			this.frameCount = 0;
			this.lastTime = currentTime;
			// Log performance warnings
			if (this.fps < 30) {
				console.warn('Low FPS detected:', this.fps);
				console.log('Active objects - Blobs:', activeBlobs.length, 'Bullets:', activeBullets.length);
			}
		}
	}
};
// Add performance monitoring to game loop if in debug mode
if (LK.debug) {
	var originalUpdate = game.update;
	game.update = function () {
		PerformanceMonitor.update();
		originalUpdate.call(this);
	};
}
/**** 
* Utility Functions
****/ 
function getDistanceBetweenPoints(p1, p2) {
	var dx = p2.x - p1.x;
	var dy = p2.y - p1.y;
	return Math.sqrt(dx * dx + dy * dy);
}
function clamp(value, min, max) {
	return Math.max(min, Math.min(max, value));
}
function lerp(start, end, factor) {
	return start + (end - start) * factor;
}
// Fibonacci sequence for costs
function fibonacci(n) {
	if (n <= 1) return 1;
	var a = 1,
		b = 1;
	for (var i = 2; i <= n; i++) {
		var temp = a + b;
		a = b;
		b = temp;
	}
	return b;
}
/**** 
* Save/Load System (Future Enhancement)
****/ 
var SaveSystem = {
	save: function save() {
		var saveData = {
			gold: gold,
			lives: lives,
			score: score,
			wave: waveManager.currentWave,
			topOrbs: [],
			bottomOrbs: []
		};
		// Save orb positions and levels
		for (var x = 0; x < GRID_COLS; x++) {
			for (var y = 0; y < GRID_ROWS; y++) {
				if (topAreaOrbs[x][y]) {
					saveData.topOrbs.push({
						x: x,
						y: y,
						type: topAreaOrbs[x][y].orbType,
						level: topAreaOrbs[x][y].level
					});
				}
				if (bottomAreaOrbs[x][y]) {
					saveData.bottomOrbs.push({
						x: x,
						y: y,
						type: bottomAreaOrbs[x][y].orbType,
						level: bottomAreaOrbs[x][y].level
					});
				}
			}
		}
		localStorage.setItem('mergeDefenseSave', JSON.stringify(saveData));
	},
	load: function load() {
		var saveData = localStorage.getItem('mergeDefenseSave');
		if (!saveData) return false;
		try {
			var data = JSON.parse(saveData);
			gold = data.gold;
			lives = data.lives;
			score = data.score;
			waveManager.currentWave = data.wave;
			// Restore orbs
			data.topOrbs.forEach(function (orbData) {
				var orb = PoolManager.getEnergyOrb();
				if (orb) {
					orb.activate(orbData.type, orbData.x, orbData.y, 0);
					orb.level = orbData.level;
					orb.updateVisuals();
					topAreaLayer.addChild(orb);
					topAreaOrbs[orbData.x][orbData.y] = orb;
				}
			});
			data.bottomOrbs.forEach(function (orbData) {
				var orb = PoolManager.getEnergyOrb();
				if (orb) {
					orb.activate(orbData.type, orbData.x, orbData.y, 1);
					orb.level = orbData.level;
					orb.updateVisuals();
					bottomAreaLayer.addChild(orb);
					bottomAreaOrbs[orbData.x][orbData.y] = orb;
				}
			});
			updateUI();
			return true;
		} catch (e) {
			console.error('Failed to load save data:', e);
			return false;
		}
	}
};
/**** 
* Audio System (Placeholder for future implementation)
****/ 
var AudioSystem = {
	playSound: function playSound(soundName) {
		// Placeholder for sound effects
		// Will be implemented when audio assets are available
		console.log('Playing sound:', soundName);
	},
	playMusic: function playMusic(musicName) {
		// Placeholder for background music
		console.log('Playing music:', musicName);
	}
};
/**** 
* Effects and Polish
****/ 
function createScreenShake(intensity, duration) {
	var originalX = game.x;
	var originalY = game.y;
	var shakeTimer = duration;
	var _shakeUpdate = function shakeUpdate() {
		if (shakeTimer > 0) {
			game.x = originalX + (Math.random() - 0.5) * intensity;
			game.y = originalY + (Math.random() - 0.5) * intensity;
			shakeTimer--;
			requestAnimationFrame(_shakeUpdate);
		} else {
			game.x = originalX;
			game.y = originalY;
		}
	};
	_shakeUpdate();
}
function createFloatingText(text, x, y, color) {
	var floatingText = new Text2(text, {
		size: 40,
		fill: color || 0xFFFFFF,
		weight: 800
	});
	floatingText.anchor.set(0.5, 0.5);
	floatingText.x = x;
	floatingText.y = y;
	floatingText.alpha = 1;
	gameLayer.addChild(floatingText);
	tween(floatingText, {
		y: y - 50,
		alpha: 0
	}, {
		duration: 1000,
		easing: tween.quadOut,
		onFinish: function onFinish() {
			gameLayer.removeChild(floatingText);
		}
	});
}
/**** 
* Game Over and Victory Screens
****/ 
LK.showGameOver = function () {
	var overlay = new Container();
	var bg = overlay.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bg.width = SCREEN_WIDTH;
	bg.height = SCREEN_HEIGHT;
	bg.tint = 0x000000;
	bg.alpha = 0.8;
	var gameOverText = new Text2('GAME OVER', {
		size: 100,
		fill: 0xFF0000,
		weight: 800
	});
	gameOverText.anchor.set(0.5, 0.5);
	gameOverText.y = -100;
	overlay.addChild(gameOverText);
	var finalScoreText = new Text2('Final Score: ' + score, {
		size: 60,
		fill: 0xFFFFFF,
		weight: 600
	});
	finalScoreText.anchor.set(0.5, 0.5);
	finalScoreText.y = 0;
	overlay.addChild(finalScoreText);
	var restartText = new Text2('Tap to Restart', {
		size: 50,
		fill: 0x00FF00,
		weight: 600
	});
	restartText.anchor.set(0.5, 0.5);
	restartText.y = 100;
	overlay.addChild(restartText);
	overlay.x = SCREEN_WIDTH / 2;
	overlay.y = SCREEN_HEIGHT / 2;
	game.addChild(overlay);
	overlay.down = function () {
		location.reload(); // Simple restart
	};
};
LK.showYouWin = function () {
	var overlay = new Container();
	var bg = overlay.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bg.width = SCREEN_WIDTH;
	bg.height = SCREEN_HEIGHT;
	bg.tint = 0x000000;
	bg.alpha = 0.8;
	var victoryText = new Text2('VICTORY!', {
		size: 100,
		fill: 0x00FF00,
		weight: 800
	});
	victoryText.anchor.set(0.5, 0.5);
	victoryText.y = -100;
	overlay.addChild(victoryText);
	var finalScoreText = new Text2('Final Score: ' + score, {
		size: 60,
		fill: 0xFFFFFF,
		weight: 600
	});
	finalScoreText.anchor.set(0.5, 0.5);
	finalScoreText.y = 0;
	overlay.addChild(finalScoreText);
	var restartText = new Text2('Tap to Play Again', {
		size: 50,
		fill: 0x00FF00,
		weight: 600
	});
	restartText.anchor.set(0.5, 0.5);
	restartText.y = 100;
	overlay.addChild(restartText);
	overlay.x = SCREEN_WIDTH / 2;
	overlay.y = SCREEN_HEIGHT / 2;
	game.addChild(overlay);
	overlay.down = function () {
		location.reload(); // Simple restart
	};
	// Victory animation
	tween(victoryText, {
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 500,
		easing: tween.elasticOut,
		repeat: -1,
		yoyo: true
	});
};

===================================================================
--- original.js
+++ change.js
@@ -1228,10 +1228,10 @@
 		// Use much more of the screen for the path
 		var pathLeft = 150; // Start near left edge of screen
 		var pathRight = SCREEN_WIDTH - 150; // Go to near right edge of screen
 		var pathTop = 400; // Start below UI
-		var pathMiddle = TOP_AREA_Y + BUILDING_AREA_HEIGHT + 150; // Between building areas
-		var pathBottom = BOTTOM_AREA_Y + BUILDING_AREA_HEIGHT + 150; // Below bottom area
+		var pathMiddle = TOP_AREA_Y + BUILDING_AREA_HEIGHT + 370; // Center path in the new 740px gap
+		var pathBottom = BOTTOM_AREA_Y + BUILDING_AREA_HEIGHT + 100; // Position path 100px below the build area
 		this.pathPoints = [
 		// Start from top-left of screen
 		{
 			x: pathLeft,
@@ -1355,9 +1355,9 @@
 // Center the building areas in the screen with proper spacing
 var TOP_AREA_X = (SCREEN_WIDTH - BUILDING_AREA_WIDTH) / 2; // ~724px from left
 var TOP_AREA_Y = 500; // Start well below UI
 var BOTTOM_AREA_X = TOP_AREA_X; // Same X position
-var BOTTOM_AREA_Y = TOP_AREA_Y + BUILDING_AREA_HEIGHT + 300; // 300px gap between areas
+var BOTTOM_AREA_Y = TOP_AREA_Y + BUILDING_AREA_HEIGHT + 740; // Increased to 740px gap between areas
 // Path uses much more of the screen
 var PATH_MARGIN = 200; // Bigger margins for wider paths
 /**** 
 * Game Variables