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

/**** 
* Classes
****/ 
var Enemy = Container.expand(function (type, pathIndex) {
	var self = Container.call(this);
	self.type = type;
	self.pathIndex = pathIndex || 0;
	self.speed = 0.5;
	self.health = 50;
	self.maxHealth = 50;
	self.damage = 10;
	self.attackCooldown = 0;
	// Use specified path index
	self.pathLane = pathIndex;
	self.currentPath = enemyPaths[self.pathLane];
	if (type === 'basic') {
		self.graphics = self.attachAsset('basicUndead', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 0.5;
		self.health = 50;
		self.maxHealth = 50;
	} else if (type === 'fast') {
		self.graphics = self.attachAsset('fastUndead', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 1;
		self.health = 30;
		self.maxHealth = 30;
	} else if (type === 'tank') {
		self.graphics = self.attachAsset('tankUndead', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 0.25;
		self.health = 150;
		self.maxHealth = 150;
		self.damage = 20;
	}
	// Set initial position
	if (self.currentPath.length > 0) {
		self.x = self.currentPath[0].x;
		self.y = self.currentPath[0].y;
	}
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.health = 0;
			return true; // enemy destroyed
		}
		return false;
	};
	self.update = function () {
		if (self.attackCooldown > 0) {
			self.attackCooldown--;
		}
		// Move along path
		if (self.pathIndex < self.currentPath.length - 1) {
			var currentTarget = self.currentPath[self.pathIndex + 1];
			var dx = currentTarget.x - self.x;
			var dy = currentTarget.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < 5) {
				self.pathIndex++;
				if (self.pathIndex >= self.currentPath.length - 1) {
					// Reached end, damage player
					playerHealth -= self.damage;
					updateUI();
					// Remove enemy
					var index = enemies.indexOf(self);
					if (index > -1) {
						enemies.splice(index, 1);
						self.destroy();
					}
					if (playerHealth <= 0) {
						LK.showGameOver();
					}
				}
			} else {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
		// Check for plant collisions
		self.checkPlantCollisions();
	};
	self.checkPlantCollisions = function () {
		for (var i = 0; i < plants.length; i++) {
			var plant = plants[i];
			if (self.intersects(plant) && self.attackCooldown <= 0) {
				var destroyed = plant.takeDamage(self.damage);
				if (destroyed) {
					plant.destroy();
					plants.splice(i, 1);
					// Remove from grid
					var gridX = Math.floor((plant.x - 24) / 100);
					var gridY = Math.floor((plant.y - 800) / 100);
					if (gridX >= 0 && gridX < gridWidth && gridY >= 0 && gridY < gridHeight) {
						grid[gridY][gridX] = 0;
					}
				}
				self.attackCooldown = 60; // 1 second cooldown
				break;
			}
		}
	};
	return self;
});
var Plant = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type;
	self.shootCooldown = 0;
	self.range = 300;
	self.damage = 20;
	self.health = 100;
	self.maxHealth = 100;
	self.sunProductionTimer = 0;
	if (type === 'peashooter') {
		self.graphics = self.attachAsset('peashooter', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.shootRate = 90; // frames between shots
		self.cost = 100;
		self.range = 300;
		self.damage = 20;
	} else if (type === 'wallnut') {
		self.graphics = self.attachAsset('wallnut', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.health = 4000;
		self.maxHealth = 4000;
		self.cost = 50;
	} else if (type === 'sunflower') {
		self.graphics = self.attachAsset('sunflower', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.cost = 50;
		self.health = 300;
		self.maxHealth = 300;
	} else if (type === 'cherrybomb') {
		self.graphics = self.attachAsset('cherrybomb', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.cost = 150;
		self.health = 200;
		self.maxHealth = 200;
		self.explosionTimer = 180; // 3 seconds at 60fps
		self.hasExploded = false;
	}
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.health = 0;
			return true; // plant destroyed
		}
		return false;
	};
	self.update = function () {
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		}
		if (self.type === 'peashooter' && self.shootCooldown <= 0) {
			var target = self.findNearestEnemy();
			if (target) {
				self.shoot(target);
				self.shootCooldown = self.shootRate;
			}
		}
		// Sunflower produces sun every 24 seconds (1440 frames at 60fps)
		if (self.type === 'sunflower') {
			self.sunProductionTimer++;
			if (self.sunProductionTimer >= 1440) {
				self.produceSun();
				self.sunProductionTimer = 0;
			}
		}
		// Cherry bomb explosion timer
		if (self.type === 'cherrybomb' && !self.hasExploded) {
			self.explosionTimer--;
			if (self.explosionTimer <= 0) {
				self.explode();
				self.hasExploded = true;
			}
		}
	};
	self.findNearestEnemy = function () {
		var nearest = null;
		var nearestDistance = self.range;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			// Check if enemy is in same lane (within 50 pixels vertically)
			if (Math.abs(enemy.y - self.y) <= 50) {
				var distance = Math.sqrt(Math.pow(enemy.x - self.x, 2) + Math.pow(enemy.y - self.y, 2));
				if (distance < nearestDistance) {
					nearest = enemy;
					nearestDistance = distance;
				}
			}
		}
		return nearest;
	};
	self.shoot = function (target) {
		var bullet = new PlantBullet(self.x, self.y, target, self.damage);
		bullets.push(bullet);
		game.addChild(bullet);
		LK.getSound('plantShoot').play();
	};
	self.produceSun = function () {
		var sun = new Sun(self.x, self.y);
		suns.push(sun);
		game.addChild(sun);
	};
	self.explode = function () {
		var explosionRadius = 200;
		// Damage all enemies in explosion radius
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var distance = Math.sqrt(Math.pow(enemy.x - self.x, 2) + Math.pow(enemy.y - self.y, 2));
			if (distance <= explosionRadius) {
				var destroyed = enemy.takeDamage(1800); // Massive damage to kill most enemies
				if (destroyed) {
					enemy.destroy();
					enemies.splice(i, 1);
					resources += 10;
					updateUI();
				}
			}
		}
		// Remove cherry bomb after explosion
		var plantIndex = plants.indexOf(self);
		if (plantIndex > -1) {
			plants.splice(plantIndex, 1);
			var gridX = Math.floor((self.x - 24) / 100);
			var gridY = Math.floor((self.y - 800) / 100);
			if (gridX >= 0 && gridX < gridWidth && gridY >= 0 && gridY < gridHeight) {
				grid[gridY][gridX] = 0;
			}
			self.destroy();
		}
	};
	return self;
});
var PlantBullet = Container.expand(function (startX, startY, target, damage) {
	var self = Container.call(this);
	self.graphics = self.attachAsset('pea', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = startX;
	self.y = startY;
	self.target = target;
	self.damage = damage;
	self.speed = 8;
	// Calculate direction to target
	var dx = target.x - startX;
	var dy = target.y - startY;
	var distance = Math.sqrt(dx * dx + dy * dy);
	self.velocityX = dx / distance * self.speed;
	self.velocityY = dy / distance * self.speed;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Check collision with target
		if (self.target && self.intersects(self.target)) {
			var destroyed = self.target.takeDamage(self.damage);
			if (destroyed) {
				// Remove enemy from array
				var index = enemies.indexOf(self.target);
				if (index > -1) {
					self.target.destroy();
					enemies.splice(index, 1);
					resources += 10;
					updateUI();
				}
			}
			// Remove bullet
			var bulletIndex = bullets.indexOf(self);
			if (bulletIndex > -1) {
				bullets.splice(bulletIndex, 1);
				self.destroy();
			}
			LK.getSound('enemyHit').play();
		}
	};
	return self;
});
var Sun = Container.expand(function (startX, startY) {
	var self = Container.call(this);
	self.graphics = self.attachAsset('sun', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = startX;
	self.y = startY;
	self.lifeTime = 600; // 10 seconds at 60fps
	self.collected = false;
	self.update = function () {
		self.lifeTime--;
		if (self.lifeTime <= 0 && !self.collected) {
			// Remove sun after timeout
			var index = suns.indexOf(self);
			if (index > -1) {
				suns.splice(index, 1);
				self.destroy();
			}
		}
	};
	self.down = function () {
		if (!self.collected) {
			self.collected = true;
			resources += 25;
			updateUI();
			// Remove sun
			var index = suns.indexOf(self);
			if (index > -1) {
				suns.splice(index, 1);
				self.destroy();
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Sound effects
// UI buttons
// Enemies
// Projectiles and effects
// Plants
// Grid and UI elements
// Game variables
var gridWidth = 20;
var gridHeight = 10;
var grid = [];
var plants = [];
var enemies = [];
var bullets = [];
var resources = 100;
var playerHealth = 100;
var waveNumber = 1;
var enemiesInWave = 5;
var enemySpawnTimer = 0;
var enemiesSpawned = 0;
var selectedPlantType = 'peashooter';
var suns = [];
var selectedCell = null;
// Multiple paths for enemies (horizontal paths from left to right)
var enemyPaths = [];
var pathRows = [2, 4, 6, 8]; // Multiple lane rows for paths
// Create paths for each lane
for (var p = 0; p < pathRows.length; p++) {
	var path = [];
	for (var i = 0; i <= gridWidth; i++) {
		path.push({
			x: i * 100 + 50,
			y: 200 + pathRows[p] * 100 + 50
		});
	}
	enemyPaths.push(path);
}
// Initialize grid
for (var y = 0; y < gridHeight; y++) {
	grid[y] = [];
	for (var x = 0; x < gridWidth; x++) {
		grid[y][x] = 0; // 0 = empty, 1 = plant, 2 = path
	}
}
// Mark path cells (horizontal lanes in multiple rows)
for (var p = 0; p < pathRows.length; p++) {
	for (var i = 0; i < gridWidth; i++) {
		grid[pathRows[p]][i] = 2; // path in lane rows
	}
}
// Create grid visual
var gridContainer = game.addChild(new Container());
gridContainer.x = 24; // Center the grid horizontally
gridContainer.y = 800; // Move grid down to accommodate horizontal layout
for (var y = 0; y < gridHeight; y++) {
	for (var x = 0; x < gridWidth; x++) {
		var cell;
		if (grid[y][x] === 2) {
			cell = LK.getAsset('pathCell', {
				anchorX: 0,
				anchorY: 0
			});
		} else {
			cell = LK.getAsset('gridCell', {
				anchorX: 0,
				anchorY: 0
			});
		}
		cell.x = x * 100;
		cell.y = y * 100;
		gridContainer.addChild(cell);
	}
}
// UI Elements
var resourceText = new Text2('Resources: ' + resources, {
	size: 40,
	fill: '#ffffff'
});
resourceText.anchor.set(0, 0);
LK.gui.topLeft.addChild(resourceText);
resourceText.x = 120;
resourceText.y = 20;
var healthText = new Text2('Health: ' + playerHealth, {
	size: 40,
	fill: '#ffffff'
});
healthText.anchor.set(0, 0);
LK.gui.topLeft.addChild(healthText);
healthText.x = 120;
healthText.y = 70;
var waveText = new Text2('Wave: ' + waveNumber, {
	size: 40,
	fill: '#ffffff'
});
waveText.anchor.set(0, 0);
LK.gui.topLeft.addChild(waveText);
waveText.x = 120;
waveText.y = 120;
// Plant selection buttons
var buttonContainer = new Container();
LK.gui.bottom.addChild(buttonContainer);
buttonContainer.y = -150;
var shooterButton = LK.getAsset('plantButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
var shooterText = new Text2('Peashooter\n$100', {
	size: 24,
	fill: '#ffffff'
});
shooterText.anchor.set(0.5, 0.5);
shooterButton.addChild(shooterText);
shooterButton.x = -200;
buttonContainer.addChild(shooterButton);
var blockerButton = LK.getAsset('plantButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
var blockerText = new Text2('Wall-nut\n$50', {
	size: 24,
	fill: '#ffffff'
});
blockerText.anchor.set(0.5, 0.5);
blockerButton.addChild(blockerText);
blockerButton.x = 0;
buttonContainer.addChild(blockerButton);
var supportButton = LK.getAsset('plantButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
var supportText = new Text2('Sunflower\n$50', {
	size: 24,
	fill: '#ffffff'
});
supportText.anchor.set(0.5, 0.5);
supportButton.addChild(supportText);
supportButton.x = 200;
buttonContainer.addChild(supportButton);
var bombButton = LK.getAsset('plantButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
var bombText = new Text2('Cherry Bomb\n$150', {
	size: 24,
	fill: '#ffffff'
});
bombText.anchor.set(0.5, 0.5);
bombButton.addChild(bombText);
bombButton.x = 400;
buttonContainer.addChild(bombButton);
// Button interactions
shooterButton.down = function () {
	selectedPlantType = 'peashooter';
	updateButtonSelection();
};
blockerButton.down = function () {
	selectedPlantType = 'wallnut';
	updateButtonSelection();
};
supportButton.down = function () {
	selectedPlantType = 'sunflower';
	updateButtonSelection();
};
bombButton.down = function () {
	selectedPlantType = 'cherrybomb';
	updateButtonSelection();
};
function updateButtonSelection() {
	shooterButton.tint = selectedPlantType === 'peashooter' ? 0x90ee90 : 0xffffff;
	blockerButton.tint = selectedPlantType === 'wallnut' ? 0x90ee90 : 0xffffff;
	supportButton.tint = selectedPlantType === 'sunflower' ? 0x90ee90 : 0xffffff;
	bombButton.tint = selectedPlantType === 'cherrybomb' ? 0x90ee90 : 0xffffff;
}
updateButtonSelection();
function updateUI() {
	resourceText.setText('Resources: ' + resources);
	healthText.setText('Health: ' + playerHealth);
	waveText.setText('Wave: ' + waveNumber);
}
function getPlantCost(type) {
	switch (type) {
		case 'peashooter':
			return 100;
		case 'wallnut':
			return 50;
		case 'sunflower':
			return 50;
		case 'cherrybomb':
			return 150;
		default:
			return 50;
	}
}
function placePlant(gridX, gridY) {
	if (gridX < 0 || gridX >= gridWidth || gridY < 0 || gridY >= gridHeight) return;
	if (grid[gridY][gridX] !== 0) return; // cell not empty
	var cost = getPlantCost(selectedPlantType);
	if (resources < cost) return;
	var plant = new Plant(selectedPlantType);
	plant.x = 24 + gridX * 100 + 50;
	plant.y = 800 + gridY * 100 + 50;
	plants.push(plant);
	game.addChild(plant);
	grid[gridY][gridX] = 1;
	resources -= cost;
	updateUI();
	LK.getSound('plantPlace').play();
}
function spawnEnemy() {
	var enemyType = 'basic';
	if (waveNumber > 3) {
		var rand = Math.random();
		if (rand < 0.3) enemyType = 'fast';else if (rand < 0.6) enemyType = 'tank';
	}
	// Only spawn enemies in light green path areas (cells marked as type 2)
	var validLanes = [];
	for (var i = 0; i < pathRows.length; i++) {
		// Verify this row has path cells (type 2)
		var rowHasPath = false;
		for (var x = 0; x < gridWidth; x++) {
			if (grid[pathRows[i]][x] === 2) {
				rowHasPath = true;
				break;
			}
		}
		if (rowHasPath) {
			validLanes.push(i);
		}
	}
	var randomLane = validLanes[Math.floor(Math.random() * validLanes.length)];
	var enemy = new Enemy(enemyType, randomLane);
	enemies.push(enemy);
	game.addChild(enemy);
}
function startNextWave() {
	waveNumber++;
	enemiesInWave = Math.min(5 + waveNumber * 2, 20);
	enemiesSpawned = 0;
	enemySpawnTimer = 0;
	updateUI();
}
// Game input handling
game.down = function (x, y, obj) {
	// Check if click is in grid area
	if (y >= 800 && y < 800 + gridHeight * 100 && x >= 24 && x < 24 + gridWidth * 100) {
		var gridX = Math.floor((x - 24) / 100);
		var gridY = Math.floor((y - 800) / 100);
		placePlant(gridX, gridY);
	}
};
// Main game loop
game.update = function () {
	// Update plants
	for (var i = plants.length - 1; i >= 0; i--) {
		plants[i].update();
	}
	// Update enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		enemies[i].update();
	}
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		if (bullets[i]) {
			bullets[i].update();
			// Remove bullets that are off screen
			if (bullets[i].x < -50 || bullets[i].x > 2100 || bullets[i].y < -50 || bullets[i].y > 2800) {
				bullets[i].destroy();
				bullets.splice(i, 1);
			}
		}
	}
	// Update suns
	for (var i = suns.length - 1; i >= 0; i--) {
		suns[i].update();
	}
	// Spawn enemies
	if (enemiesSpawned < enemiesInWave) {
		enemySpawnTimer++;
		if (enemySpawnTimer >= 360) {
			// spawn every 6 seconds
			spawnEnemy();
			enemiesSpawned++;
			enemySpawnTimer = 0;
		}
	}
	// Check wave completion
	if (enemiesSpawned >= enemiesInWave && enemies.length === 0) {
		if (waveNumber >= 10) {
			LK.showYouWin();
		} else {
			// Bonus resources for completing wave
			resources += 25;
			updateUI();
			// Start next wave after delay
			LK.setTimeout(function () {
				startNextWave();
			}, 2000);
		}
	}
};
// Start first wave
enemySpawnTimer = 0;
enemiesSpawned = 0;

===================================================================
--- original.js
+++ change.js
@@ -554,12 +554,22 @@
 	if (waveNumber > 3) {
 		var rand = Math.random();
 		if (rand < 0.3) enemyType = 'fast';else if (rand < 0.6) enemyType = 'tank';
 	}
-	// Only spawn enemies in light green path areas (pathRows)
+	// Only spawn enemies in light green path areas (cells marked as type 2)
 	var validLanes = [];
 	for (var i = 0; i < pathRows.length; i++) {
-		validLanes.push(i);
+		// Verify this row has path cells (type 2)
+		var rowHasPath = false;
+		for (var x = 0; x < gridWidth; x++) {
+			if (grid[pathRows[i]][x] === 2) {
+				rowHasPath = true;
+				break;
+			}
+		}
+		if (rowHasPath) {
+			validLanes.push(i);
+		}
 	}
 	var randomLane = validLanes[Math.floor(Math.random() * validLanes.length)];
 	var enemy = new Enemy(enemyType, randomLane);
 	enemies.push(enemy);