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

/**** 
* Classes
****/ 
// BuildTile class (for tower placement)
var BuildTile = Container.expand(function () {
	var self = Container.call(this);
	// Attach tile asset (box, light gray)
	var tileAsset = self.attachAsset('buildTile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.occupied = false;
	self.tower = null;
	// For highlighting
	self.highlight = function (on) {
		tileAsset.tint = on ? 0x2ecc40 : 0xbdc3c7;
	};
	return self;
});
// Bullet class
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	// Attach bullet asset (small yellow box)
	var bulletAsset = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.target = null;
	self.damage = 5;
	self.speed = 24;
	self.update = function () {
		if (!self.target || self.target.health <= 0 || self.target.reachedBase) {
			self.destroyed = true;
			return;
		}
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist < 32) {
			// Hit
			self.target.takeDamage(self.damage);
			self.destroyed = true;
			return;
		}
		var moveDist = Math.min(self.speed, dist);
		self.x += dx / dist * moveDist;
		self.y += dy / dist * moveDist;
	};
	return self;
});
// Enemy (Creep) class
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	// Attach enemy asset (ellipse, purple)
	var enemyAsset = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Enemy stats
	self.maxHealth = 10 + (currentWave - 1) * 5;
	self.health = self.maxHealth;
	self.speed = 2 + (currentWave - 1) * 0.2; // Slightly faster each wave
	self.reward = 5 + (currentWave - 1) * 2;
	// Path progress
	self.pathIndex = 0;
	self.pathProgress = 0;
	// For hit flash
	self.isFlashing = false;
	// Move along path
	self.update = function () {
		if (self.pathIndex >= path.length - 1) return;
		var from = path[self.pathIndex];
		var to = path[self.pathIndex + 1];
		var dx = to.x - from.x;
		var dy = to.y - from.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist === 0) {
			self.pathIndex++;
			self.pathProgress = 0;
			return;
		}
		var moveDist = self.speed;
		self.pathProgress += moveDist;
		if (self.pathProgress >= dist) {
			self.pathIndex++;
			self.pathProgress = 0;
			if (self.pathIndex >= path.length - 1) {
				// Reached end
				self.x = to.x;
				self.y = to.y;
				self.reachedBase = true;
				return;
			}
		}
		var t = self.pathProgress / dist;
		self.x = from.x + dx * t;
		self.y = from.y + dy * t;
	};
	// Take damage
	self.takeDamage = function (dmg) {
		self.health -= dmg;
		if (!self.isFlashing) {
			self.isFlashing = true;
			tween(enemyAsset, {
				tint: 0xffffff
			}, {
				duration: 80,
				onFinish: function onFinish() {
					tween(enemyAsset, {
						tint: 0x8e44ad
					}, {
						duration: 120,
						onFinish: function onFinish() {
							self.isFlashing = false;
						}
					});
				}
			});
		}
	};
	return self;
});
// Tower class
var Tower = Container.expand(function () {
	var self = Container.call(this);
	// Attach tower asset (box, blue)
	var towerAsset = self.attachAsset('tower', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Tower stats
	self.level = 1;
	self.range = 320;
	self.damage = 5;
	self.fireRate = 60; // frames per shot
	self.cooldown = 0;
	// For upgrade flash
	self.isFlashing = false;
	// Show range circle (for placement)
	self.rangeCircle = self.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.15
	});
	self.rangeCircle.width = self.range * 2;
	self.rangeCircle.height = self.range * 2;
	self.rangeCircle.visible = false;
	// Upgrade tower
	self.upgrade = function () {
		if (self.level >= 3) return false;
		self.level++;
		self.damage += 5;
		self.range += 40;
		self.fireRate = Math.max(30, self.fireRate - 10);
		self.rangeCircle.width = self.range * 2;
		self.rangeCircle.height = self.range * 2;
		// Flash for upgrade
		if (!self.isFlashing) {
			self.isFlashing = true;
			tween(towerAsset, {
				tint: 0xffff00
			}, {
				duration: 120,
				onFinish: function onFinish() {
					tween(towerAsset, {
						tint: 0x3498db
					}, {
						duration: 180,
						onFinish: function onFinish() {
							self.isFlashing = false;
						}
					});
				}
			});
		}
		return true;
	};
	// Tower attack logic
	self.update = function () {
		if (self.cooldown > 0) {
			self.cooldown--;
			return;
		}
		// Find nearest enemy in range
		var nearest = null;
		var minDist = 99999;
		for (var i = 0; i < enemies.length; i++) {
			var e = enemies[i];
			var dx = e.x - self.x;
			var dy = e.y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist <= self.range && dist < minDist) {
				nearest = e;
				minDist = dist;
			}
		}
		if (nearest) {
			// Shoot
			var b = new Bullet();
			b.x = self.x;
			b.y = self.y;
			b.target = nearest;
			b.damage = self.damage;
			b.speed = 24;
			b.lastX = b.x;
			b.lastY = b.y;
			bullets.push(b);
			game.addChild(b);
			self.cooldown = self.fireRate;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// --- Grid system ---
// Set grid to 10x15 with margins
var GRID_COLS = 10;
var GRID_ROWS = 15;
var GRID_SIZE = 160;
// Calculate margins to center grid in 2048x2732
var GRID_TOTAL_WIDTH = GRID_COLS * GRID_SIZE;
var GRID_TOTAL_HEIGHT = GRID_ROWS * GRID_SIZE;
var GRID_MARGIN_X = Math.floor((2048 - GRID_TOTAL_WIDTH) / 2);
var GRID_MARGIN_Y = Math.floor((2732 - GRID_TOTAL_HEIGHT) / 2);
// Helper to snap to grid (with margin)
function snapToGrid(x, y) {
	return {
		x: GRID_MARGIN_X + Math.round((x - GRID_MARGIN_X) / GRID_SIZE) * GRID_SIZE,
		y: GRID_MARGIN_Y + Math.round((y - GRID_MARGIN_Y) / GRID_SIZE) * GRID_SIZE
	};
}
// Path definition (array of {x, y}), snapped to grid
// Generate a random path from top row to bottom row, always moving to adjacent grid cells
function generateRandomPath() {
	var pathArr = [];
	// Start at random column on top row
	var col = Math.floor(Math.random() * GRID_COLS);
	var row = 0;
	pathArr.push(snapToGrid(GRID_MARGIN_X + col * GRID_SIZE, GRID_MARGIN_Y + row * GRID_SIZE));
	var visited = {};
	visited[col + "," + row] = true;
	// Random walk to bottom row
	while (row < GRID_ROWS - 1) {
		var options = [];
		// Can move down
		if (row + 1 < GRID_ROWS && !visited[col + "," + (row + 1)]) options.push({
			col: col,
			row: row + 1
		});
		// Can move left
		if (col - 1 >= 0 && !visited[col - 1 + "," + row]) options.push({
			col: col - 1,
			row: row
		});
		// Can move right
		if (col + 1 < GRID_COLS && !visited[col + 1 + "," + row]) options.push({
			col: col + 1,
			row: row
		});
		// Prefer down, but randomize
		if (options.length === 0) break;
		var next = options[Math.floor(Math.random() * options.length)];
		col = next.col;
		row = next.row;
		pathArr.push(snapToGrid(GRID_MARGIN_X + col * GRID_SIZE, GRID_MARGIN_Y + row * GRID_SIZE));
		visited[col + "," + row] = true;
	}
	return pathArr;
}
var path = generateRandomPath();
// --- Start Game Button Logic ---
var gameStarted = false;
var startBtn = new Text2('▶ Start Game', {
	size: 120,
	fill: 0x27AE60
});
startBtn.anchor.set(0.5, 0.5);
LK.gui.center.addChild(startBtn);
function setStartBtnVisible(visible) {
	startBtn.visible = visible;
}
setStartBtnVisible(true);
startBtn.down = function (x, y, obj) {
	if (!gameStarted) {
		gameStarted = true;
		setStartBtnVisible(false);
		setNextWaveBtnVisible(true);
		startWave(); // Start the first wave immediately
	}
};
// Hide all gameplay UI until game starts
setNextWaveBtnVisible(false);
if (typeof kpTxt !== "undefined") kpTxt.visible = false;
if (typeof healthTxt !== "undefined") healthTxt.visible = false;
if (typeof waveTxt !== "undefined") waveTxt.visible = false;
if (typeof nextWaveBtn !== "undefined") nextWaveBtn.visible = false;
if (typeof autoNextWaveBtn !== "undefined") autoNextWaveBtn.visible = false;
// Show gameplay UI when game starts
function showGameplayUI() {
	kpTxt.visible = true;
	healthTxt.visible = true;
	waveTxt.visible = true;
	nextWaveBtn.visible = false;
	nextWaveBtn.x = 0;
	nextWaveBtn.y = kpTxt.y + kpTxt.height + 20;
	autoNextWaveBtn.x = 0;
	autoNextWaveBtn.y = nextWaveBtn.y + nextWaveBtn.height + 10;
	autoNextWaveBtn.visible = true;
	kpTxt.setText('Points: ' + knowledgePoints);
	healthTxt.setText('Base: ' + baseHealth);
	waveTxt.setText('Wave: ' + currentWave + '/' + maxWaves);
}
var _origStartWave = startWave;
startWave = function startWave() {
	if (!gameStarted) return;
	showGameplayUI();
	_origStartWave();
};
// Buildable tile logic removed for now
var buildTilePositions = [];
// Global game state
var enemies = [];
var towers = [];
var bullets = [];
// buildTiles removed for now
var baseHealth = 10;
var knowledgePoints = 30;
var currentWave = 1;
var maxWaves = 10;
var waveInProgress = false;
var waveTimer = null;
var spawnIndex = 0;
var spawnDelay = 40; // frames between spawns
var enemiesToSpawn = 0;
var selectedTile = null;
// Asset initialization
// Draw grid background (light gray squares) with margins and 10x15 grid area
for (var row = 0; row < GRID_ROWS; row++) {
	for (var col = 0; col < GRID_COLS; col++) {
		var gridNode = LK.getAsset('buildTile', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: GRID_SIZE - 4,
			height: GRID_SIZE - 4,
			color: 0xf4f4f4,
			shape: 'box',
			alpha: 0.18
		});
		gridNode.x = GRID_MARGIN_X + col * GRID_SIZE;
		gridNode.y = GRID_MARGIN_Y + row * GRID_SIZE;
		game.addChild(gridNode);
	}
}
// Draw path (for visual reference)
for (var i = 0; i < path.length - 1; i++) {
	var from = path[i];
	var to = path[i + 1];
	var dx = to.x - from.x;
	var dy = to.y - from.y;
	var dist = Math.sqrt(dx * dx + dy * dy);
	var steps = Math.floor(dist / 40);
	for (var s = 0; s <= steps; s++) {
		var t = s / steps;
		var px = from.x + dx * t;
		var py = from.y + dy * t;
		var node = LK.getAsset('pathDot', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 32,
			height: 32,
			color: 0x7f8c8d,
			shape: 'ellipse'
		});
		node.x = px;
		node.y = py;
		game.addChild(node);
	}
}
// Buildable tile objects removed for now
// --- Tower Selection Bar ---
var towerTypes = [{
	id: 'tower',
	name: 'Normal',
	color: 0x3498db,
	cost: 20,
	range: 320,
	damage: 5,
	fireRate: 60
}
// You can add more tower types here later
];
var selectedTowerType = towerTypes[0]; // Default selected
// Create tower selection buttons at the bottom
var towerButtons = [];
// Move tower selection bar up so it's visible and not too close to the bottom
var towerBtnY = 2400; // was 2600, now 2400 for better visibility
var towerBtnSpacing = 260;
var towerBtnStartX = 400;
// Drag-and-drop state for tower placement
var draggingTowerType = null;
var draggingTowerGhost = null;
for (var i = 0; i < towerTypes.length; i++) {
	var t = towerTypes[i];
	var btn = LK.getAsset(t.id, {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 180,
		height: 180,
		color: t.color,
		shape: 'box'
	});
	btn.x = towerBtnStartX + i * towerBtnSpacing;
	btn.y = towerBtnY;
	btn.towerType = t;
	btn.selected = i === 0;
	btn.alpha = btn.selected ? 1 : 0.5;
	// Add label
	var label = new Text2(t.name, {
		size: 60,
		fill: "#fff"
	});
	label.anchor.set(0.5, 0);
	// Place label above the button for better visibility
	label.x = btn.x;
	label.y = btn.y - 120;
	game.addChild(btn);
	game.addChild(label);
	towerButtons.push(btn);
	// Touch event for drag-and-drop
	btn.down = function (btn) {
		return function (x, y, obj) {
			for (var j = 0; j < towerButtons.length; j++) {
				towerButtons[j].selected = false;
				towerButtons[j].alpha = 0.5;
			}
			btn.selected = true;
			btn.alpha = 1;
			selectedTowerType = btn.towerType;
			// Start dragging a ghost tower
			if (draggingTowerGhost) {
				draggingTowerGhost.destroy();
				draggingTowerGhost = null;
			}
			draggingTowerType = btn.towerType;
			draggingTowerGhost = LK.getAsset(btn.towerType.id, {
				anchorX: 0.5,
				anchorY: 0.5,
				width: 120,
				height: 120,
				color: btn.towerType.color,
				shape: 'box',
				alpha: 0.5
			});
			draggingTowerGhost.rangeCircle = LK.getAsset('rangeCircle', {
				anchorX: 0.5,
				anchorY: 0.5,
				alpha: 0.10
			});
			draggingTowerGhost.rangeCircle.width = btn.towerType.range * 2;
			draggingTowerGhost.rangeCircle.height = btn.towerType.range * 2;
			game.addChild(draggingTowerGhost.rangeCircle);
			game.addChild(draggingTowerGhost);
		};
	}(btn);
}
// Handle dragging ghost tower with finger/mouse
game.move = function (x, y, obj) {
	if (draggingTowerGhost) {
		draggingTowerGhost.x = x;
		draggingTowerGhost.y = y;
		if (draggingTowerGhost.rangeCircle) {
			draggingTowerGhost.rangeCircle.x = x;
			draggingTowerGhost.rangeCircle.y = y;
		}
		// No build tile highlight logic for now
	}
};
// Place tower on build tile on up
game.up = function (x, y, obj) {
	if (draggingTowerGhost && draggingTowerType) {
		// No build tile placement for now
		if (draggingTowerGhost.rangeCircle) draggingTowerGhost.rangeCircle.destroy();
		draggingTowerGhost.destroy();
		draggingTowerGhost = null;
		draggingTowerType = null;
		return;
	}
	// If not placing, just clear ghost
	if (draggingTowerGhost) {
		if (draggingTowerGhost.rangeCircle) draggingTowerGhost.rangeCircle.destroy();
		draggingTowerGhost.destroy();
		draggingTowerGhost = null;
		draggingTowerType = null;
	}
};
// Base indicator (ellipse, red)
var baseNode = LK.getAsset('base', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 160,
	height: 160,
	color: 0xe74c3c,
	shape: 'ellipse'
});
baseNode.x = path[path.length - 1].x;
baseNode.y = path[path.length - 1].y;
game.addChild(baseNode);
// GUI: Points (KP) - Center top, smaller size, renamed to Points
var kpTxt = new Text2('Points: ' + knowledgePoints, {
	size: 48,
	fill: 0x222222
});
kpTxt.anchor.set(0.5, 0); // center aligned, top
kpTxt.x = 0;
kpTxt.y = 10;
LK.gui.top.addChild(kpTxt);
// GUI: Base Health - Top right, smaller size
var healthTxt = new Text2('Base: ' + baseHealth, {
	size: 48,
	fill: 0xE74C3C
});
healthTxt.anchor.set(1, 0); // right aligned, top
healthTxt.x = -40; // right margin
healthTxt.y = 10;
LK.gui.topRight.addChild(healthTxt);
// GUI: Wave - Bottom left, smaller size
var waveTxt = new Text2('Wave: ' + currentWave + '/' + maxWaves, {
	size: 48,
	fill: 0x2980B9
});
waveTxt.anchor.set(0, 1); // left aligned, bottom
waveTxt.x = 40;
waveTxt.y = -40;
LK.gui.bottomLeft.addChild(waveTxt);
// GUI: Next Wave Button
var nextWaveBtn = new Text2('▶ Next Wave', {
	size: 90,
	fill: 0x27AE60
});
nextWaveBtn.anchor.set(0.5, 0);
// Place nextWaveBtn under Points (kpTxt) in gui.top, centered horizontally
nextWaveBtn.x = 0;
nextWaveBtn.y = kpTxt.y + kpTxt.height + 20;
LK.gui.top.addChild(nextWaveBtn);
// Auto-next wave toggle
var autoNextWave = false;
var autoNextWaveBtn = new Text2('Auto: OFF', {
	size: 54,
	fill: 0x2980B9
});
autoNextWaveBtn.anchor.set(0.5, 0);
autoNextWaveBtn.x = 0;
autoNextWaveBtn.y = nextWaveBtn.y + nextWaveBtn.height + 10;
LK.gui.top.addChild(autoNextWaveBtn);
autoNextWaveBtn.visible = false;
autoNextWaveBtn.down = function (x, y, obj) {
	autoNextWave = !autoNextWave;
	autoNextWaveBtn.setText('Auto: ' + (autoNextWave ? 'ON' : 'OFF'));
};
// Show/hide next wave button
function setNextWaveBtnVisible(visible) {
	// Defensive: Only set visible if nextWaveBtn is defined and has a visible property
	if (typeof nextWaveBtn !== "undefined" && nextWaveBtn && typeof nextWaveBtn.visible !== "undefined") {
		nextWaveBtn.visible = visible;
	}
}
setNextWaveBtnVisible(false);
// Start next wave
function startWave() {
	if (waveInProgress || currentWave > maxWaves) return;
	waveInProgress = true;
	setNextWaveBtnVisible(false);
	enemiesToSpawn = 6 + currentWave * 2;
	spawnIndex = 0;
}
// Next wave button event
nextWaveBtn.down = function (x, y, obj) {
	if (!waveInProgress && currentWave <= maxWaves) {
		startWave();
	}
};
// Build/upgrade tower on tile
function tryBuildOrUpgrade(tile) {
	if (tile.occupied) {
		// Try upgrade
		if (tile.tower.level < 3) {
			var upgradeCost = 20 + tile.tower.level * 15;
			if (knowledgePoints >= upgradeCost) {
				knowledgePoints -= upgradeCost;
				tile.tower.upgrade();
				kpTxt.setText('Points: ' + knowledgePoints);
			}
		}
	} else {
		// Build new tower
		var buildCost = 20;
		if (knowledgePoints >= buildCost) {
			knowledgePoints -= buildCost;
			var tower = new Tower();
			tower.x = tile.x;
			tower.y = tile.y;
			towers.push(tower);
			game.addChild(tower);
			tile.occupied = true;
			tile.tower = tower;
			kpTxt.setText('Points: ' + knowledgePoints);
		}
	}
}
// Highlight build tiles on touch
game.down = function (x, y, obj) {
	// No tap-to-place logic; only drag-and-drop is supported for tower placement
};
// Remove highlight/range on up
// (handled by drag-and-drop up logic above)
// Main game update
game.update = function () {
	// Spawn enemies for wave
	if (waveInProgress && enemiesToSpawn > 0 && LK.ticks % spawnDelay === 0) {
		var enemy = new Enemy();
		enemy.x = path[0].x;
		enemy.y = path[0].y;
		enemy.pathIndex = 0;
		enemy.pathProgress = 0;
		enemies.push(enemy);
		game.addChild(enemy);
		enemiesToSpawn--;
	}
	// Update enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		var e = enemies[i];
		e.update();
		if (e.health <= 0) {
			// Enemy defeated
			knowledgePoints += e.reward;
			kpTxt.setText('Points: ' + knowledgePoints);
			e.destroy();
			enemies.splice(i, 1);
			kpTxt.setText('Points: ' + knowledgePoints);
		} else if (e.reachedBase) {
			// Enemy reached base
			baseHealth--;
			healthTxt.setText('Base: ' + baseHealth);
			e.destroy();
			enemies.splice(i, 1);
			healthTxt.setText('Base: ' + baseHealth);
			LK.effects.flashScreen(0xe74c3c, 400);
			if (baseHealth <= 0) {
				LK.showGameOver();
				return;
			}
		}
	}
	// Update towers
	for (var i = 0; i < towers.length; i++) {
		towers[i].update();
	}
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		var b = bullets[i];
		b.update();
		if (b.destroyed) {
			b.destroy();
			bullets.splice(i, 1);
		}
	}
	// End wave if all enemies defeated and none left to spawn
	if (waveInProgress && enemies.length === 0 && enemiesToSpawn === 0) {
		waveInProgress = false;
		currentWave++;
		if (currentWave > maxWaves) {
			LK.showYouWin();
			return;
		}
		waveTxt.setText('Wave: ' + currentWave + '/' + maxWaves);
		// Reposition nextWaveBtn and autoNextWaveBtn under Points (kpTxt) in case Points text size changes
		nextWaveBtn.x = 0;
		nextWaveBtn.y = kpTxt.y + kpTxt.height + 20;
		autoNextWaveBtn.x = 0;
		autoNextWaveBtn.y = nextWaveBtn.y + nextWaveBtn.height + 10;
		if (autoNextWave) {
			setNextWaveBtnVisible(false);
			// Start next wave automatically after a short delay for feedback
			LK.setTimeout(function () {
				if (!waveInProgress && currentWave <= maxWaves) {
					startWave();
				}
			}, 700);
		} else {
			setNextWaveBtnVisible(true);
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -244,12 +244,46 @@
 		y: GRID_MARGIN_Y + Math.round((y - GRID_MARGIN_Y) / GRID_SIZE) * GRID_SIZE
 	};
 }
 // Path definition (array of {x, y}), snapped to grid
-// Example path: left edge, down, right, down, right, down to base
-var path = [snapToGrid(GRID_MARGIN_X + 0 * GRID_SIZE, GRID_MARGIN_Y + 1 * GRID_SIZE),
-// start
-snapToGrid(GRID_MARGIN_X + 0 * GRID_SIZE, GRID_MARGIN_Y + 6 * GRID_SIZE), snapToGrid(GRID_MARGIN_X + 4 * GRID_SIZE, GRID_MARGIN_Y + 6 * GRID_SIZE), snapToGrid(GRID_MARGIN_X + 4 * GRID_SIZE, GRID_MARGIN_Y + 11 * GRID_SIZE), snapToGrid(GRID_MARGIN_X + 9 * GRID_SIZE, GRID_MARGIN_Y + 11 * GRID_SIZE), snapToGrid(GRID_MARGIN_X + 9 * GRID_SIZE, GRID_MARGIN_Y + 14 * GRID_SIZE)];
+// Generate a random path from top row to bottom row, always moving to adjacent grid cells
+function generateRandomPath() {
+	var pathArr = [];
+	// Start at random column on top row
+	var col = Math.floor(Math.random() * GRID_COLS);
+	var row = 0;
+	pathArr.push(snapToGrid(GRID_MARGIN_X + col * GRID_SIZE, GRID_MARGIN_Y + row * GRID_SIZE));
+	var visited = {};
+	visited[col + "," + row] = true;
+	// Random walk to bottom row
+	while (row < GRID_ROWS - 1) {
+		var options = [];
+		// Can move down
+		if (row + 1 < GRID_ROWS && !visited[col + "," + (row + 1)]) options.push({
+			col: col,
+			row: row + 1
+		});
+		// Can move left
+		if (col - 1 >= 0 && !visited[col - 1 + "," + row]) options.push({
+			col: col - 1,
+			row: row
+		});
+		// Can move right
+		if (col + 1 < GRID_COLS && !visited[col + 1 + "," + row]) options.push({
+			col: col + 1,
+			row: row
+		});
+		// Prefer down, but randomize
+		if (options.length === 0) break;
+		var next = options[Math.floor(Math.random() * options.length)];
+		col = next.col;
+		row = next.row;
+		pathArr.push(snapToGrid(GRID_MARGIN_X + col * GRID_SIZE, GRID_MARGIN_Y + row * GRID_SIZE));
+		visited[col + "," + row] = true;
+	}
+	return pathArr;
+}
+var path = generateRandomPath();
 // --- Start Game Button Logic ---
 var gameStarted = false;
 var startBtn = new Text2('▶ Start Game', {
 	size: 120,
@@ -296,57 +330,15 @@
 	if (!gameStarted) return;
 	showGameplayUI();
 	_origStartWave();
 };
-// Buildable tile positions (placed around the path, on grid, adjacent to path cells)
+// Buildable tile logic removed for now
 var buildTilePositions = [];
-for (var i = 0; i < path.length; i++) {
-	var p = path[i];
-	// For each path node, try to add build tiles to the 4 adjacent grid cells (N, S, E, W)
-	var adjacents = [{
-		x: p.x + GRID_SIZE,
-		y: p.y
-	}, {
-		x: p.x - GRID_SIZE,
-		y: p.y
-	}, {
-		x: p.x,
-		y: p.y + GRID_SIZE
-	}, {
-		x: p.x,
-		y: p.y - GRID_SIZE
-	}];
-	for (var j = 0; j < adjacents.length; j++) {
-		var pos = adjacents[j];
-		// Don't add if already in path or already in buildTilePositions
-		var isOnPath = false;
-		for (var k = 0; k < path.length; k++) {
-			if (path[k].x === pos.x && path[k].y === pos.y) {
-				isOnPath = true;
-				break;
-			}
-		}
-		var alreadyAdded = false;
-		for (var k = 0; k < buildTilePositions.length; k++) {
-			if (buildTilePositions[k].x === pos.x && buildTilePositions[k].y === pos.y) {
-				alreadyAdded = true;
-				break;
-			}
-		}
-		// Only add if inside grid bounds, not on path, not already added
-		if (!isOnPath && !alreadyAdded && pos.x >= 0 && pos.x < GRID_COLS * GRID_SIZE && pos.y >= 0 && pos.y < GRID_ROWS * GRID_SIZE) {
-			buildTilePositions.push({
-				x: pos.x,
-				y: pos.y
-			});
-		}
-	}
-}
 // Global game state
 var enemies = [];
 var towers = [];
 var bullets = [];
-var buildTiles = [];
+// buildTiles removed for now
 var baseHealth = 10;
 var knowledgePoints = 30;
 var currentWave = 1;
 var maxWaves = 10;
@@ -398,17 +390,9 @@
 		node.y = py;
 		game.addChild(node);
 	}
 }
-// Place buildable tiles (with margin-aware positions)
-for (var i = 0; i < buildTilePositions.length; i++) {
-	var pos = buildTilePositions[i];
-	var tile = new BuildTile();
-	tile.x = pos.x;
-	tile.y = pos.y;
-	buildTiles.push(tile);
-	game.addChild(tile);
-}
+// Buildable tile objects removed for now
 // --- Tower Selection Bar ---
 var towerTypes = [{
 	id: 'tower',
 	name: 'Normal',
@@ -502,65 +486,19 @@
 		if (draggingTowerGhost.rangeCircle) {
 			draggingTowerGhost.rangeCircle.x = x;
 			draggingTowerGhost.rangeCircle.y = y;
 		}
-		// Highlight build tile under ghost
-		var found = false;
-		for (var i = 0; i < buildTiles.length; i++) {
-			var tile = buildTiles[i];
-			var dx = x - tile.x;
-			var dy = y - tile.y;
-			if (dx * dx + dy * dy < 70 * 70 && !tile.occupied) {
-				tile.highlight(true);
-				found = true;
-			} else {
-				tile.highlight(false);
-			}
-		}
+		// No build tile highlight logic for now
 	}
 };
 // Place tower on build tile on up
 game.up = function (x, y, obj) {
 	if (draggingTowerGhost && draggingTowerType) {
-		// Find nearest build tile within range
-		var minDist = 99999;
-		var nearestTile = null;
-		for (var i = 0; i < buildTiles.length; i++) {
-			var tile = buildTiles[i];
-			var dx = x - tile.x;
-			var dy = y - tile.y;
-			var dist = dx * dx + dy * dy;
-			if (dist < 70 * 70 && !tile.occupied && dist < minDist) {
-				minDist = dist;
-				nearestTile = tile;
-			}
-		}
-		if (nearestTile) {
-			var buildCost = draggingTowerType.cost;
-			if (knowledgePoints >= buildCost) {
-				knowledgePoints -= buildCost;
-				var tower = new Tower();
-				tower.x = nearestTile.x;
-				tower.y = nearestTile.y;
-				tower.range = draggingTowerType.range;
-				tower.damage = draggingTowerType.damage;
-				tower.fireRate = draggingTowerType.fireRate;
-				tower.rangeCircle.width = tower.range * 2;
-				tower.rangeCircle.height = tower.range * 2;
-				towers.push(tower);
-				game.addChild(tower);
-				nearestTile.occupied = true;
-				nearestTile.tower = tower;
-				kpTxt.setText('Points: ' + knowledgePoints);
-			}
-		}
-		for (var i = 0; i < buildTiles.length; i++) {
-			buildTiles[i].highlight(false);
-		}
+		// No build tile placement for now
 		if (draggingTowerGhost.rangeCircle) draggingTowerGhost.rangeCircle.destroy();
 		draggingTowerGhost.destroy();
 		draggingTowerGhost = null;
-		// Do NOT clear draggingTowerType here, so player can place multiple towers in a row
+		draggingTowerType = null;
 		return;
 	}
 	// If not placing, just clear ghost
 	if (draggingTowerGhost) {