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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function (startX, startY, target, damage) {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = startX;
	self.y = startY;
	self.target = target;
	self.damage = damage;
	self.speed = 8;
	self.update = function () {
		if (!self.target || self.target.parent === null) {
			// Target destroyed, remove bullet
			self.destroy();
			var index = bullets.indexOf(self);
			if (index > -1) bullets.splice(index, 1);
			return;
		}
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 20) {
			// Hit target
			self.target.takeDamage(self.damage);
			self.destroy();
			var index = bullets.indexOf(self);
			if (index > -1) bullets.splice(index, 1);
		} else {
			// Move towards target
			var moveX = dx / distance * self.speed;
			var moveY = dy / distance * self.speed;
			self.x += moveX;
			self.y += moveY;
		}
	};
	return self;
});
var Noob = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'basic';
	var assetId = 'noob';
	self.maxHealth = 100;
	self.speed = 2;
	self.reward = 10;
	if (self.type === 'fast') {
		assetId = 'fastNoob';
		self.maxHealth = 60;
		self.speed = 4;
		self.reward = 15;
	} else if (self.type === 'strong') {
		assetId = 'strongNoob';
		self.maxHealth = 200;
		self.speed = 1.5;
		self.reward = 25;
	}
	var noobGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = self.maxHealth;
	self.pathIndex = 0;
	self.targetX = pathPoints[0].x;
	self.targetY = pathPoints[0].y;
	self.update = function () {
		// Move towards current target
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 10) {
			// Reached current target, move to next
			self.pathIndex++;
			if (self.pathIndex >= pathPoints.length) {
				// Reached base
				baseHealth -= 20;
				self.destroy();
				var index = noobs.indexOf(self);
				if (index > -1) noobs.splice(index, 1);
				return;
			}
			self.targetX = pathPoints[self.pathIndex].x;
			self.targetY = pathPoints[self.pathIndex].y;
		} else {
			// Move towards target
			var moveX = dx / distance * self.speed;
			var moveY = dy / distance * self.speed;
			self.x += moveX;
			self.y += moveY;
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.getSound('enemyHit').play();
		// Flash red when hit
		tween(noobGraphics, {
			tint: 0xFF0000
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(noobGraphics, {
					tint: 0xFFFFFF
				}, {
					duration: 100
				});
			}
		});
		if (self.health <= 0) {
			currency += self.reward;
			LK.getSound('enemyDeath').play();
			self.destroy();
			var index = noobs.indexOf(self);
			if (index > -1) noobs.splice(index, 1);
		}
	};
	return self;
});
var Tower = Container.expand(function (gridX, gridY, towerType) {
	var self = Container.call(this);
	self.gridX = gridX;
	self.gridY = gridY;
	self.level = 1;
	self.towerType = towerType || 'basic';
	var typeData = towerTypes[self.towerType];
	self.damage = typeData.damage;
	self.range = typeData.range;
	self.attackSpeed = self.towerType === 'rapid' ? 30 : 60; // frames between attacks
	self.cost = typeData.cost;
	self.upgradeCost = Math.floor(typeData.cost * 1.5);
	self.lastAttack = 0;
	var towerGraphics = self.attachAsset(typeData.asset, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = gridX * 128 + 64;
	self.y = gridY * 128 + 64;
	self.update = function () {
		self.lastAttack++;
		if (self.lastAttack >= self.attackSpeed) {
			// Look for enemies in range
			var target = null;
			var closestDistance = self.range;
			for (var i = 0; i < noobs.length; i++) {
				var noob = noobs[i];
				var dx = noob.x - self.x;
				var dy = noob.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance <= self.range && distance < closestDistance) {
					target = noob;
					closestDistance = distance;
				}
			}
			if (target) {
				self.shoot(target);
				self.lastAttack = 0;
			}
		}
	};
	self.shoot = function (target) {
		var bullet = new Bullet(self.x, self.y, target, self.damage);
		game.addChild(bullet);
		bullets.push(bullet);
		LK.getSound('shoot').play();
	};
	self.upgrade = function () {
		if (self.level < 3 && currency >= self.upgradeCost) {
			currency -= self.upgradeCost;
			self.level++;
			self.damage += 15;
			self.range += 25;
			self.upgradeCost = Math.floor(self.upgradeCost * 1.5);
			if (self.level >= 2) {
				towerGraphics.removeChild();
				towerGraphics = self.attachAsset('upgradedTower', {
					anchorX: 0.5,
					anchorY: 0.5
				});
			}
			// Visual upgrade effect
			tween(self, {
				scaleX: 1.2,
				scaleY: 1.2
			}, {
				duration: 200,
				onFinish: function onFinish() {
					tween(self, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 200
					});
				}
			});
		}
	};
	self.down = function (x, y, obj) {
		if (selectedTower !== self) {
			selectedTower = self;
			updateUI();
		} else {
			self.upgrade();
			updateUI();
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Sounds
// UI Elements
// Base
// Projectiles
// Towers
// Noobs
// Path tiles
// Game variables
var pathPoints = [{
	x: 0,
	y: 384
}, {
	x: 256,
	y: 384
}, {
	x: 256,
	y: 768
}, {
	x: 640,
	y: 768
}, {
	x: 640,
	y: 1152
}, {
	x: 1024,
	y: 1152
}, {
	x: 1024,
	y: 1536
}, {
	x: 1408,
	y: 1536
}, {
	x: 1408,
	y: 1920
}, {
	x: 1792,
	y: 1920
}, {
	x: 1792,
	y: 2304
}, {
	x: 2048,
	y: 2304
}];
var noobs = [];
var towers = [];
var bullets = [];
var currency = 100;
var baseHealth = 100;
var wave = 1;
var enemiesInWave = 5;
var enemiesSpawned = 0;
var waveComplete = true;
var spawnTimer = 0;
var selectedTower = null;
// Create path visualization
function createPath() {
	for (var i = 0; i < pathPoints.length - 1; i++) {
		var start = pathPoints[i];
		var end = pathPoints[i + 1];
		// Create tiles between points
		var steps = Math.max(Math.abs(end.x - start.x), Math.abs(end.y - start.y)) / 128;
		for (var j = 0; j <= steps; j++) {
			var x = start.x + (end.x - start.x) * (j / steps);
			var y = start.y + (end.y - start.y) * (j / steps);
			var pathTile = LK.getAsset('pathTile', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			pathTile.x = x;
			pathTile.y = y;
			game.addChild(pathTile);
		}
	}
	// Initialize path tiles data for tower placement checking
	createPathTiles();
}
// Create grass background
function createBackground() {
	for (var x = 0; x < 16; x++) {
		for (var y = 0; y < 22; y++) {
			var grassTile = LK.getAsset('grassTile', {
				anchorX: 0,
				anchorY: 0
			});
			grassTile.x = x * 128;
			grassTile.y = y * 128;
			game.addChild(grassTile);
		}
	}
}
// Create base
var base = LK.getAsset('base', {
	anchorX: 0.5,
	anchorY: 0.5
});
base.x = pathPoints[pathPoints.length - 1].x;
base.y = pathPoints[pathPoints.length - 1].y;
// UI Elements
var currencyText = new Text2('Currency: 100', {
	size: 60,
	fill: 0xFFD700
});
currencyText.anchor.set(0, 0);
var healthText = new Text2('Base Health: 100', {
	size: 60,
	fill: 0xFF6B6B
});
healthText.anchor.set(0, 0);
var waveText = new Text2('Wave: 1', {
	size: 60,
	fill: 0x4ECDC4
});
waveText.anchor.set(0, 0);
var towerInfoText = new Text2('Tap the PLACE TOWER button, then tap empty space to build', {
	size: 40,
	fill: 0xFFFFFF
});
towerInfoText.anchor.set(0.5, 0);
// Tower selection variables
var selectedTowerType = 'basic';
var towerTypes = {
	basic: {
		cost: 50,
		damage: 25,
		range: 150,
		asset: 'basicTower',
		name: 'Basic Tower'
	},
	cannon: {
		cost: 100,
		damage: 50,
		range: 120,
		asset: 'upgradedTower',
		name: 'Cannon Tower'
	},
	rapid: {
		cost: 75,
		damage: 15,
		range: 180,
		asset: 'basicTower',
		name: 'Rapid Tower'
	}
};
// Create eye-catching tower placement UI bar
var towerPlacementBar = new Container();
towerPlacementBar.x = 0;
towerPlacementBar.y = 2732 - 200; // Position at bottom with more height
// Create vibrant background for placement bar using a shape asset
var placementBarBg = LK.getAsset('grassTile', {
	anchorX: 0,
	anchorY: 0
});
placementBarBg.width = 2048;
placementBarBg.height = 200;
placementBarBg.tint = 0x8B4513; // Brown (cafe) background
towerPlacementBar.addChild(placementBarBg);
// Create prominent tower placement button
var towerPlacementButton = new Container();
towerPlacementButton.x = 1024; // Center horizontally
towerPlacementButton.y = 100; // Center vertically in bar
// Create large, eye-catching button background
var buttonBg = LK.getAsset('towerButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
buttonBg.width = 300; // Make it bigger
buttonBg.height = 120;
buttonBg.tint = 0x4ECDC4; // Bright cyan
towerPlacementButton.addChild(buttonBg);
// Add tower icon
var towerIcon = LK.getAsset('basicTower', {
	anchorX: 0.5,
	anchorY: 0.5
});
towerIcon.scale.set(1.2); // Make icon bigger
towerIcon.x = -40; // Position to left side of button
towerPlacementButton.addChild(towerIcon);
// Add "PLACE TOWER" text
var placeTowerText = new Text2('PLACE TOWER', {
	size: 36,
	fill: 0xFFFFFF
});
placeTowerText.anchor.set(0.5, 0.5);
placeTowerText.x = 40; // Position to right of icon
towerPlacementButton.addChild(placeTowerText);
// Add cost display
var costDisplayText = new Text2('Cost: 50', {
	size: 28,
	fill: 0xFFD700
});
costDisplayText.anchor.set(0.5, 0.5);
costDisplayText.y = 30; // Below main text
costDisplayText.x = 40;
towerPlacementButton.addChild(costDisplayText);
// Button interaction variables
var canPlaceTowers = false;
var buttonBgOriginalTint = 0x4ECDC4;
// Button press handler
towerPlacementButton.down = function (x, y, obj) {
	canPlaceTowers = !canPlaceTowers; // Toggle placement mode
	updatePlacementButton();
};
function updatePlacementButton() {
	if (canPlaceTowers) {
		buttonBg.tint = 0x00FF88; // Bright green when active
		placeTowerText.setText('TAP TO PLACE');
		// Add pulsing animation
		tween(buttonBg, {
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 500,
			repeat: -1,
			yoyo: true
		});
	} else {
		buttonBg.tint = buttonBgOriginalTint; // Original color when inactive
		placeTowerText.setText('PLACE TOWER');
		// Stop any animations
		tween.stop(buttonBg);
		buttonBg.scaleX = 1;
		buttonBg.scaleY = 1;
	}
	costDisplayText.setText('Cost: ' + towerTypes[selectedTowerType].cost);
}
// Add border to make bar more visible
var borderTop = LK.getAsset('pathTile', {
	anchorX: 0,
	anchorY: 0
});
borderTop.width = 2048;
borderTop.height = 8;
borderTop.tint = 0x000000; // Black border
borderTop.y = -4; // Position at top of bar
towerPlacementBar.addChild(borderTop);
towerPlacementBar.addChild(towerPlacementButton);
game.addChild(towerPlacementBar);
// Update placement button display
function updateTowerSelection() {
	updatePlacementButton();
}
// Position UI elements
LK.gui.top.addChild(currencyText);
LK.gui.top.addChild(healthText);
LK.gui.top.addChild(waveText);
LK.gui.bottom.addChild(towerInfoText);
healthText.y = 70;
waveText.y = 140;
function updateUI() {
	currencyText.setText('Currency: ' + currency);
	healthText.setText('Base Health: ' + baseHealth);
	waveText.setText('Wave: ' + wave);
	if (selectedTower) {
		towerInfoText.setText('Tower Level ' + selectedTower.level + ' | Upgrade Cost: ' + selectedTower.upgradeCost + ' | Tap again to upgrade');
	} else if (canPlaceTowers) {
		towerInfoText.setText('PLACEMENT MODE ACTIVE - Tap empty space to build tower (Cost: ' + towerTypes[selectedTowerType].cost + ')');
	} else {
		towerInfoText.setText('Tap the PLACE TOWER button, then tap empty space to build');
	}
}
function startNextWave() {
	wave++;
	enemiesInWave = Math.floor(5 + wave * 1.5);
	enemiesSpawned = 0;
	waveComplete = false;
	spawnTimer = 0;
	selectedTower = null;
	updateUI();
}
function spawnEnemy() {
	var enemyType = 'basic';
	if (wave > 3 && Math.random() < 0.3) {
		enemyType = 'fast';
	}
	if (wave > 5 && Math.random() < 0.2) {
		enemyType = 'strong';
	}
	var noob = new Noob(enemyType);
	noob.x = pathPoints[0].x;
	noob.y = pathPoints[0].y;
	noobs.push(noob);
	game.addChild(noob);
	enemiesSpawned++;
}
// Create a set to store all path grid positions
var pathTiles = [];
function createPathTiles() {
	pathTiles = [];
	for (var i = 0; i < pathPoints.length - 1; i++) {
		var start = pathPoints[i];
		var end = pathPoints[i + 1];
		// Create tiles between points
		var steps = Math.max(Math.abs(end.x - start.x), Math.abs(end.y - start.y)) / 128;
		for (var j = 0; j <= steps; j++) {
			var x = start.x + (end.x - start.x) * (j / steps);
			var y = start.y + (end.y - start.y) * (j / steps);
			var gridX = Math.floor(x / 128);
			var gridY = Math.floor(y / 128);
			// Add to path tiles if not already added
			var found = false;
			for (var k = 0; k < pathTiles.length; k++) {
				if (pathTiles[k].x === gridX && pathTiles[k].y === gridY) {
					found = true;
					break;
				}
			}
			if (!found) {
				pathTiles.push({
					x: gridX,
					y: gridY
				});
			}
		}
	}
}
function canPlaceTower(gridX, gridY) {
	// Check if position is on path
	for (var i = 0; i < pathTiles.length; i++) {
		if (pathTiles[i].x === gridX && pathTiles[i].y === gridY) {
			return false;
		}
	}
	// Check if tower already exists
	for (var i = 0; i < towers.length; i++) {
		if (towers[i].gridX === gridX && towers[i].gridY === gridY) {
			return false;
		}
	}
	return true;
}
// Initialize game elements
createBackground();
createPath();
game.addChild(base);
// Game event handlers
game.down = function (x, y, obj) {
	// Check if click is in tower placement bar area
	if (y > 2732 - 200) {
		return; // Let tower placement button handle this
	}
	// Only allow tower placement if placement mode is active
	if (canPlaceTowers) {
		var gridX = Math.floor(x / 128);
		var gridY = Math.floor(y / 128);
		var towerCost = towerTypes[selectedTowerType].cost;
		if (canPlaceTower(gridX, gridY) && currency >= towerCost) {
			var tower = new Tower(gridX, gridY, selectedTowerType);
			towers.push(tower);
			game.addChild(tower);
			currency -= towerCost;
			selectedTower = tower;
			canPlaceTowers = false; // Disable placement mode after placing
			updatePlacementButton();
			updateUI();
		} else {
			selectedTower = null;
			updateUI();
		}
	} else {
		// If not in placement mode, just select existing towers
		selectedTower = null;
		updateUI();
	}
};
game.update = function () {
	// Check game over
	if (baseHealth <= 0) {
		LK.showGameOver();
		return;
	}
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		if (bullet.parent) {
			bullet.update();
		}
	}
	// Spawn enemies
	if (!waveComplete) {
		spawnTimer++;
		if (spawnTimer >= 90 && enemiesSpawned < enemiesInWave) {
			spawnEnemy();
			spawnTimer = 0;
		}
		if (enemiesSpawned >= enemiesInWave && noobs.length === 0) {
			waveComplete = true;
			currency += 20; // Wave completion bonus
			updateUI();
		}
	} else if (LK.ticks % 180 === 0) {
		// Auto-start next wave after 3 seconds
		startNextWave();
	}
	// Update UI periodically
	if (LK.ticks % 30 === 0) {
		updateUI();
	}
};
// Initialize tower selection
updateTowerSelection();
// Start first wave
updateUI();
startNextWave();

===================================================================
--- original.js
+++ change.js
@@ -377,9 +377,9 @@
 	anchorY: 0
 });
 placementBarBg.width = 2048;
 placementBarBg.height = 200;
-placementBarBg.tint = 0xFF6B35; // Bright orange background
+placementBarBg.tint = 0x8B4513; // Brown (cafe) background
 towerPlacementBar.addChild(placementBarBg);
 // Create prominent tower placement button
 var towerPlacementButton = new Container();
 towerPlacementButton.x = 1024; // Center horizontally