/**** 
* 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.speed = 0.5;
	self.health = 50;
	self.maxHealth = 50;
	self.damage = 10;
	self.attackCooldown = 0;
	// Use specified path index
	self.pathLane = pathIndex;
	self.targetRow = pathRows[pathIndex];
	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;
	}
	// Position will be set by spawnEnemy function
	self.x = 0;
	self.y = 0;
	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 straight horizontally from left to right
		self.x += self.speed;
		// Check if reached end of screen
		if (self.x > 2048 + 100) {
			// Reached end of screen, 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();
			}
		}
		// 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 front of plant (to the right)
			if (enemy.x > self.x) {
				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;
	// Shoot straight horizontally to the right
	self.velocityX = self.speed;
	self.velocityY = 0;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Check collision with any enemy
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (self.intersects(enemy)) {
				var destroyed = enemy.takeDamage(self.damage);
				if (destroyed) {
					// Remove enemy from array
					var index = enemies.indexOf(enemy);
					if (index > -1) {
						enemy.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; // Exit after hitting first enemy
			}
		}
	};
	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';
	}
	// Spawn enemies in any available lane
	var randomLane = Math.floor(Math.random() * pathRows.length);
	var enemy = new Enemy(enemyType, randomLane);
	// Spawn enemy at left side of screen at random Y position
	enemy.x = -50; // Start from left edge
	enemy.y = 800 + Math.random() * (gridHeight * 100); // Random Y position within grid
	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] && (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
@@ -59,11 +59,11 @@
 			self.attackCooldown--;
 		}
 		// Move straight horizontally from left to right
 		self.x += self.speed;
-		// Check if reached end of grid (not screen)
-		if (self.x > 24 + gridWidth * 100 - 50) {
-			// Reached end of grid, damage player
+		// Check if reached end of screen
+		if (self.x > 2048 + 100) {
+			// Reached end of screen, damage player
 			playerHealth -= self.damage;
 			updateUI();
 			// Remove enemy
 			var index = enemies.indexOf(self);
@@ -185,10 +185,10 @@
 		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) OR in lanes below the plant
-			if (Math.abs(enemy.y - self.y) <= 50 && enemy.x > self.x || enemy.y > self.y && enemy.x > self.x) {
+			// Check if enemy is in front of plant (to the right)
+			if (enemy.x > self.x) {
 				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;
@@ -542,57 +542,14 @@
 	if (waveNumber > 3) {
 		var rand = Math.random();
 		if (rand < 0.3) enemyType = 'fast';else if (rand < 0.6) enemyType = 'tank';
 	}
-	// Spawn enemies only in lanes where plants are present
-	var validLanes = [];
-	for (var i = 0; i < pathRows.length; i++) {
-		// Check if this row has any plants
-		var rowHasPlants = false;
-		for (var x = 0; x < gridWidth; x++) {
-			if (grid[pathRows[i]][x] === 1) {
-				rowHasPlants = true;
-				break;
-			}
-		}
-		// Only add lane if it has plants AND path cells
-		if (rowHasPlants) {
-			var rowHasPath = false;
-			for (var x = 0; x < gridWidth; x++) {
-				if (grid[pathRows[i]][x] === 2) {
-					rowHasPath = true;
-					break;
-				}
-			}
-			if (rowHasPath) {
-				validLanes.push(i);
-			}
-		}
-	}
-	// If no valid lanes with plants, don't spawn enemy
-	if (validLanes.length === 0) {
-		return;
-	}
-	var randomLane = validLanes[Math.floor(Math.random() * validLanes.length)];
-	// Ensure enemy spawns only within light green path cells (type 2)
-	var spawnRow = pathRows[randomLane];
-	// Find valid spawn positions only in light green cells
-	var validSpawnPositions = [];
-	for (var x = 0; x < gridWidth; x++) {
-		if (grid[spawnRow][x] === 2) {
-			validSpawnPositions.push(x);
-		}
-	}
-	// If no valid spawn positions in light green cells, don't spawn
-	if (validSpawnPositions.length === 0) {
-		return;
-	}
+	// Spawn enemies in any available lane
+	var randomLane = Math.floor(Math.random() * pathRows.length);
 	var enemy = new Enemy(enemyType, randomLane);
-	// Spawn enemy in a random valid grid cell within the lane
-	var spawnRow = pathRows[randomLane];
-	var randomSpawnX = validSpawnPositions[Math.floor(Math.random() * validSpawnPositions.length)];
-	enemy.x = 24 + randomSpawnX * 100 + 50; // Center of selected grid cell
-	enemy.y = 800 + spawnRow * 100 + 50; // Center of target row
+	// Spawn enemy at left side of screen at random Y position
+	enemy.x = -50; // Start from left edge
+	enemy.y = 800 + Math.random() * (gridHeight * 100); // Random Y position within grid
 	enemies.push(enemy);
 	game.addChild(enemy);
 }
 function startNextWave() {