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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('Bala', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.target = null;
	self.speed = 600; // pixels per second
	self.damage = 0;
	self.update = function () {
		if (self.target && self.target.parent) {
			// Calculate direction to target
			var dx = self.target.x - self.x;
			var dy = self.target.y - self.y;
			var distanceSquared = dx * dx + dy * dy;
			// If close enough to target, hit it (using squared distance to avoid sqrt)
			if (distanceSquared < 400) {
				// 20 * 20 = 400
				// Apply damage to enemy using its takeDamage method
				if (self.target.takeDamage) {
					self.target.takeDamage(self.damage);
				}
				// Add damage to tower's total damage counter
				if (self.towerRef && self.towerRef.parent) {
					self.towerRef.totalDamage += self.damage;
				}
				// Remove bullet
				self.destroy();
				return;
			}
			// Move towards target
			var distance = Math.sqrt(distanceSquared);
			var moveX = dx / distance * self.speed * frameTime; // 60 FPS
			var moveY = dy / distance * self.speed * frameTime;
			self.x += moveX;
			self.y += moveY;
			// Rotate bullet to face target
			self.rotation = Math.atan2(dy, dx);
		} else {
			// Target is gone, remove bullet
			self.destroy();
		}
	};
	return self;
});
// Reusable tower creation function
var Gameplay = Container.expand(function () {
	var self = Container.call(this);
	var gameplayGraphics = self.attachAsset('gameplayBackground', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var UI = Container.expand(function () {
	var self = Container.call(this);
	var uiGraphics = self.attachAsset('uiBackground', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});

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

/**** 
* Game Code
****/ 
// Reusable tower creation function
function createTowerBase(params) {
	return Container.expand(function () {
		var self = Container.call(this);
		// Tower parameters
		self.damage = params.damage;
		self.cadence = params.cadence;
		self.range = params.range;
		self.rangeSquared = self.range * self.range; // Cache squared range for optimization
		self.totalDamage = 0; // Track total damage dealt by this tower
		var areaGraphics = self.attachAsset('Area', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Scale the area to match the tower's actual range
		var areaScale = self.range * 2 / 100; // Area asset is 100x100, so scale to range diameter
		areaGraphics.scaleX = areaScale;
		areaGraphics.scaleY = areaScale;
		areaGraphics.alpha = 0.3;
		areaGraphics.visible = false; // Hide range area by default
		var towerGraphics = self.attachAsset(params.asset, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Method to show range area
		self.showRange = function () {
			areaGraphics.visible = true;
		};
		// Method to hide range area
		self.hideRange = function () {
			areaGraphics.visible = false;
		};
		// Tower selection state
		self.isSelected = false;
		// Tower placement state
		self.isPlaced = false;
		// Shooting properties
		self.lastShotTime = 0;
		self.bullets = [];
		// Method to find enemies in range
		self.findEnemiesInRange = function () {
			var enemies = [];
			// Check if enemyTest is in range
			if (enemyTest && enemyTest.parent) {
				var dx = enemyTest.x - self.x;
				var dy = enemyTest.y - self.y;
				var distanceSquared = dx * dx + dy * dy;
				if (distanceSquared <= self.rangeSquared) {
					enemies.push(enemyTest);
				}
			}
			return enemies;
		};
		// Method to shoot at target
		self.shoot = function (target) {
			var currentTime = Date.now();
			if (currentTime - self.lastShotTime >= self.cadence) {
				var bullet = new Bullet();
				// Calculate direction to target for bullet offset
				var dx = target.x - self.x;
				var dy = target.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				var offsetDistance = 50; // Distance to spawn bullet ahead of tower
				// Spawn bullet slightly ahead in the direction of the target
				bullet.x = self.x + dx / distance * offsetDistance;
				bullet.y = self.y + dy / distance * offsetDistance;
				bullet.target = target;
				bullet.damage = self.damage;
				bullet.towerRef = self; // Store reference to the tower that fired this bullet
				self.bullets.push(bullet);
				game.addChild(bullet);
				self.lastShotTime = currentTime;
				// Play bullet shooting sound
				LK.getSound('Balababa').play();
				// Add squash animation to tower
				tween.stop(towerGraphics, {
					scaleX: true
				}); // Stop any existing scale tweens
				tween(towerGraphics, {
					scaleX: 0.7
				}, {
					duration: 100,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(towerGraphics, {
							scaleX: 1.0
						}, {
							duration: 150,
							easing: tween.easeOut
						});
					}
				});
			}
		};
		// Update method for tower
		self.update = function () {
			// Clean up destroyed bullets
			for (var i = self.bullets.length - 1; i >= 0; i--) {
				if (!self.bullets[i].parent) {
					self.bullets.splice(i, 1);
				}
			}
			// Only shoot if tower is placed (check cached status)
			if (self.isPlaced) {
				// Find and shoot at enemies
				var enemies = self.findEnemiesInRange();
				if (enemies.length > 0) {
					var target = enemies[0];
					// Calculate angle to target
					var dx = target.x - self.x;
					var dy = target.y - self.y;
					var targetAngle = Math.atan2(dy, dx);
					// Rotate tower to face target
					towerGraphics.rotation = targetAngle;
					// Flip tower horizontally if target is on the left side
					if (dx < 0) {
						towerGraphics.scaleY = -1; // Flip on Y axis when target is to the left
					} else {
						towerGraphics.scaleY = 1; // Normal orientation when target is to the right
					}
					// Shoot at the first enemy found
					self.shoot(target);
				}
			}
		};
		// Handle tower selection
		self.down = function (x, y, obj) {
			// Deselect all other towers first
			for (var i = 0; i < placedTowers.length; i++) {
				if (placedTowers[i] !== self) {
					placedTowers[i].isSelected = false;
					placedTowers[i].hideRange();
				}
			}
			// Toggle selection for this tower
			self.isSelected = !self.isSelected;
			if (self.isSelected) {
				self.showRange();
				updateTowerUpgrade(self); // Update UI with this tower's upgrade options
			} else {
				self.hideRange();
				updateTowerUpgrade(null); // Clear UI when deselected
			}
		};
		return self;
	});
}
var FastTower = createTowerBase({
	damage: 1,
	// Lower damage than regular tower
	cadence: 400,
	// Faster shooting (400ms vs 1000ms)
	range: 350,
	// Slightly shorter range
	asset: 'torreFast'
});
var Tower = createTowerBase({
	damage: 1,
	// Damage dealt per shot
	cadence: 1000,
	// Time between shots in milliseconds (1 second)
	range: 400,
	// Range in pixels
	asset: 'torreInicial'
});
var draggedTower = null;
var isDragging = false;
var placedTowers = []; // Track all placed towers
// Cache frequently used values
var gameplayBounds = null;
var uiBounds = null;
var frameTime = 1 / 60; // Cache frame time calculation
// Reusable tower creation function that accepts tower constructor
function createTowerButton(color, x, y, TowerClass) {
	var buttonBG = game.addChild(LK.getAsset('BGbuttonTower', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.5,
		scaleY: 1.5
	}));
	buttonBG.x = x;
	buttonBG.y = y;
	var button = game.addChild(new TowerClass());
	button.x = x;
	button.y = y;
	button.tint = color;
	// Store reference to button background for easy access
	button.buttonBG = buttonBG;
	button.down = function (x, y, obj) {
		isDragging = true;
		draggedTower = game.addChild(new TowerClass());
		draggedTower.x = button.x;
		draggedTower.y = button.y;
		draggedTower.alpha = 0.7;
		draggedTower.tint = color;
		draggedTower.showRange(); // Show range area when dragging
	};
	return button;
}
// Game down handler to deselect towers when clicking on gameplay area
game.down = function (x, y, obj) {
	// Check if click is in gameplay area (not on UI or towers)
	var gameplayBounds = getGameplayBounds();
	var clickInGameplay = x >= gameplayBounds.left && x <= gameplayBounds.right && y >= gameplayBounds.top && y <= gameplayBounds.bottom;
	if (clickInGameplay) {
		// Deselect all towers
		for (var i = 0; i < placedTowers.length; i++) {
			placedTowers[i].isSelected = false;
			placedTowers[i].hideRange();
		}
		updateTowerUpgrade(null); // Clear tower upgrade when no tower is selected
	}
};
// Helper functions for bounds calculations
function getGameplayBounds() {
	return {
		left: gameplay.x - gameplay.width / 2,
		right: gameplay.x + gameplay.width / 2,
		top: gameplay.y - gameplay.height / 2,
		bottom: gameplay.y + gameplay.height / 2,
		centerX: gameplay.x,
		centerY: gameplay.y
	};
}
function getUIBounds() {
	return {
		left: ui.x - ui.width / 2,
		right: ui.x + ui.width / 2,
		top: ui.y - ui.height / 2,
		bottom: ui.y + ui.height / 2
	};
}
function isPointInUI(x, y) {
	var bounds = getUIBounds();
	return x >= bounds.left && x <= bounds.right && y >= bounds.top && y <= bounds.bottom;
}
function calculateDragOffset(x, y) {
	var bounds = getGameplayBounds();
	var distanceFromCenterX = Math.abs(x - bounds.centerX);
	var distanceFromCenterY = Math.abs(y - bounds.centerY);
	var maxDistanceX = gameplay.width / 2;
	var maxDistanceY = gameplay.height / 2;
	var normalizedDistanceX = distanceFromCenterX / maxDistanceX;
	var normalizedDistanceY = distanceFromCenterY / maxDistanceY;
	var maxOffset = 200;
	var offsetMagnitudeX = maxOffset * normalizedDistanceX;
	var offsetMagnitudeY = maxOffset * normalizedDistanceY;
	var offsetX = 0;
	var offsetY = 0;
	if (x >= bounds.centerX && y <= bounds.centerY) {
		offsetX = offsetMagnitudeX;
		offsetY = -offsetMagnitudeY;
	} else if (x <= bounds.centerX && y <= bounds.centerY) {
		offsetX = -offsetMagnitudeX;
		offsetY = -offsetMagnitudeY;
	} else if (x <= bounds.centerX && y >= bounds.centerY) {
		offsetX = -offsetMagnitudeX;
		offsetY = offsetMagnitudeY;
	} else if (x >= bounds.centerX && y >= bounds.centerY) {
		offsetX = offsetMagnitudeX;
		offsetY = offsetMagnitudeY;
	}
	return {
		offsetX: offsetX,
		offsetY: offsetY
	};
}
// Layer management - objects are added in z-index order (bottom to top)
// Background layer
var gameplay = game.addChild(new Gameplay());
gameplay.x = 1024;
gameplay.y = 1093;
// Game objects layer (towers will be added here)
// UI layer
var ui = game.addChild(new UI());
ui.x = 1024;
ui.y = 2459;
// Create multiple tower creation buttons with different colors
var towerButtons = [];
var buttonSpacing = 300; // Increased spacing between buttons
var startX = 300; // Starting X position
towerButtons.push(createTowerButton(0xffffff, startX, 2459, Tower)); // White tower (normal)
towerButtons.push(createTowerButton(0xff0000, startX + buttonSpacing, 2459, FastTower)); // Red tower (fast)
towerButtons.push(createTowerButton(0x00ff00, startX + buttonSpacing * 2, 2459, Tower)); // Green tower (normal)
towerButtons.push(createTowerButton(0x0000ff, startX + buttonSpacing * 3, 2459, Tower)); // Blue tower (normal)
// Enemy test object in the center with health layers
var enemyTest = game.addChild(LK.getAsset('Puntero', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 5,
	scaleY: 5,
	color: 0x00ff00 // Start with green
}));
enemyTest.x = 1024;
enemyTest.y = 1093;
// Health system for enemy
enemyTest.maxHealth = 3; // Total health across all layers (3 layers)
enemyTest.currentHealth = enemyTest.maxHealth;
enemyTest.healthLayers = [{
	min: 3,
	max: 3,
	color: 0x00ff00
},
// Green layer (1 HP)
{
	min: 2,
	max: 2,
	color: 0x0000ff
},
// Blue layer (1 HP)
{
	min: 1,
	max: 1,
	color: 0xff0000
} // Red layer (1 HP)
];
// Method to update enemy color based on health
enemyTest.updateHealthColor = function () {
	for (var i = 0; i < this.healthLayers.length; i++) {
		var layer = this.healthLayers[i];
		if (this.currentHealth >= layer.min && this.currentHealth <= layer.max) {
			// Animate color transition using tween
			tween(this, {
				tint: layer.color
			}, {
				duration: 200,
				easing: tween.easeOut
			});
			break;
		}
	}
};
// Method to take damage
enemyTest.takeDamage = function (damage) {
	var oldHealth = this.currentHealth;
	this.currentHealth = Math.max(0, this.currentHealth - damage);
	// Check if we crossed a layer boundary
	var oldLayer = -1;
	var newLayer = -1;
	for (var i = 0; i < this.healthLayers.length; i++) {
		var layer = this.healthLayers[i];
		if (oldHealth >= layer.min && oldHealth <= layer.max) {
			oldLayer = i;
		}
		if (this.currentHealth >= layer.min && this.currentHealth <= layer.max) {
			newLayer = i;
		}
	}
	// Update color if we changed layers or if this is the first damage
	if (oldLayer !== newLayer || oldHealth === this.maxHealth) {
		this.updateHealthColor();
	}
	// Check if enemy is dead
	if (this.currentHealth <= 0) {
		// Enemy is destroyed, respawn with full health
		this.currentHealth = this.maxHealth;
		this.updateHealthColor();
	}
};
// Initialize enemy color
enemyTest.updateHealthColor();
// Enemy is now stationary - no movement code needed
// UI mode management
var UI_MODE_TOWER_CREATION = 'creation';
var UI_MODE_TOWER_UPGRADE = 'upgrade';
var currentUIMode = UI_MODE_TOWER_CREATION;
// UI Upgrade panel for selected tower
var towerUpgradeContainer = game.addChild(new Container());
towerUpgradeContainer.x = 1024;
towerUpgradeContainer.y = 2250;
var upgradeTitle = towerUpgradeContainer.addChild(new Text2('Upgrade Tower', {
	size: 100,
	fill: 0xFFFFFF
}));
upgradeTitle.anchor.set(0.5, 0);
upgradeTitle.x = 0;
upgradeTitle.y = 0;
// Upgrade damage button
var upgradeDamageButtonBG = towerUpgradeContainer.addChild(LK.getAsset('BGbuttonTower', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 1.4,
	scaleY: 1.4
}));
upgradeDamageButtonBG.x = -300;
upgradeDamageButtonBG.y = 180;
upgradeDamageButtonBG.tint = 0xFFFF00;
var upgradeDamageText = towerUpgradeContainer.addChild(new Text2('DMG+', {
	size: 70,
	fill: 0x000000
}));
upgradeDamageText.anchor.set(0.5, 0.5);
upgradeDamageText.x = -300;
upgradeDamageText.y = 180;
// Upgrade speed button
var upgradeSpeedButtonBG = towerUpgradeContainer.addChild(LK.getAsset('BGbuttonTower', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 1.4,
	scaleY: 1.4
}));
upgradeSpeedButtonBG.x = 0;
upgradeSpeedButtonBG.y = 180;
upgradeSpeedButtonBG.tint = 0x00FF00;
var upgradeSpeedText = towerUpgradeContainer.addChild(new Text2('SPD+', {
	size: 70,
	fill: 0x000000
}));
upgradeSpeedText.anchor.set(0.5, 0.5);
upgradeSpeedText.x = 0;
upgradeSpeedText.y = 180;
// Upgrade range button
var upgradeRangeButtonBG = towerUpgradeContainer.addChild(LK.getAsset('BGbuttonTower', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 1.4,
	scaleY: 1.4
}));
upgradeRangeButtonBG.x = 300;
upgradeRangeButtonBG.y = 180;
upgradeRangeButtonBG.tint = 0x00FFFF;
var upgradeRangeText = towerUpgradeContainer.addChild(new Text2('RNG+', {
	size: 70,
	fill: 0x000000
}));
upgradeRangeText.anchor.set(0.5, 0.5);
upgradeRangeText.x = 300;
upgradeRangeText.y = 180;
// Delete button at bottom right of upgrade panel
var deleteTowerButtonBG = towerUpgradeContainer.addChild(LK.getAsset('BGbuttonTower', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 1.4,
	scaleY: 1.4
}));
deleteTowerButtonBG.x = 500;
deleteTowerButtonBG.y = 180;
deleteTowerButtonBG.tint = 0xff0000;
var deleteTowerButtonText = towerUpgradeContainer.addChild(new Text2('DEL', {
	size: 70,
	fill: 0xFFFFFF
}));
deleteTowerButtonText.anchor.set(0.5, 0.5);
deleteTowerButtonText.x = 500;
deleteTowerButtonText.y = 180;
// Store reference to currently selected tower
var selectedTowerForUpgrade = null;
// Function to switch UI modes
function setUIMode(mode) {
	currentUIMode = mode;
	if (mode === UI_MODE_TOWER_CREATION) {
		// Show tower creation buttons and their backgrounds
		for (var i = 0; i < towerButtons.length; i++) {
			towerButtons[i].visible = true;
			if (towerButtons[i].buttonBG) {
				towerButtons[i].buttonBG.visible = true;
			}
		}
		// Hide tower upgrade panel
		towerUpgradeContainer.visible = false;
	} else if (mode === UI_MODE_TOWER_UPGRADE) {
		// Hide tower creation buttons and their backgrounds
		for (var i = 0; i < towerButtons.length; i++) {
			towerButtons[i].visible = false;
			if (towerButtons[i].buttonBG) {
				towerButtons[i].buttonBG.visible = false;
			}
		}
		// Show tower upgrade panel
		towerUpgradeContainer.visible = true;
	}
}
// Function to update tower upgrade display
function updateTowerUpgrade(tower) {
	if (tower) {
		// Store reference to selected tower for upgrades
		selectedTowerForUpgrade = tower;
		// Switch to tower upgrade mode when a tower is selected
		setUIMode(UI_MODE_TOWER_UPGRADE);
	} else {
		// Clear reference to selected tower
		selectedTowerForUpgrade = null;
		// Switch back to tower creation mode when no tower is selected
		setUIMode(UI_MODE_TOWER_CREATION);
	}
}
// Upgrade damage button click handler
upgradeDamageButtonBG.down = function (x, y, obj) {
	if (selectedTowerForUpgrade) {
		selectedTowerForUpgrade.damage += 1;
		// Flash button to show upgrade
		LK.effects.flashObject(upgradeDamageButtonBG, 0xFFFFFF, 300);
	}
};
// Upgrade speed button click handler
upgradeSpeedButtonBG.down = function (x, y, obj) {
	if (selectedTowerForUpgrade) {
		selectedTowerForUpgrade.cadence = Math.max(100, selectedTowerForUpgrade.cadence - 100);
		// Flash button to show upgrade
		LK.effects.flashObject(upgradeSpeedButtonBG, 0xFFFFFF, 300);
	}
};
// Upgrade range button click handler
upgradeRangeButtonBG.down = function (x, y, obj) {
	if (selectedTowerForUpgrade) {
		selectedTowerForUpgrade.range += 50;
		selectedTowerForUpgrade.rangeSquared = selectedTowerForUpgrade.range * selectedTowerForUpgrade.range;
		// Update the range area scale
		if (selectedTowerForUpgrade.children[0]) {
			var areaScale = selectedTowerForUpgrade.range * 2 / 100;
			selectedTowerForUpgrade.children[0].scaleX = areaScale;
			selectedTowerForUpgrade.children[0].scaleY = areaScale;
		}
		// Flash button to show upgrade
		LK.effects.flashObject(upgradeRangeButtonBG, 0xFFFFFF, 300);
	}
};
// Delete button click handler
deleteTowerButtonBG.down = function (x, y, obj) {
	if (selectedTowerForUpgrade) {
		// Remove tower from placed towers array
		for (var i = 0; i < placedTowers.length; i++) {
			if (placedTowers[i] === selectedTowerForUpgrade) {
				placedTowers.splice(i, 1);
				break;
			}
		}
		// Destroy the tower
		selectedTowerForUpgrade.destroy();
		// Clear tower upgrade and switch back to creation mode
		updateTowerUpgrade(null);
	}
};
// Initialize with no tower selected and tower creation mode
updateTowerUpgrade(null);
setUIMode(UI_MODE_TOWER_CREATION);
// Top overlay layer (pointer on top of everything)
var puntero = game.addChild(LK.getAsset('Puntero', {
	anchorX: 0.5,
	anchorY: 0.5
}));
puntero.x = 1024;
puntero.y = 1366;
puntero.alpha = 0;
// Game move handler for dragging
game.move = function (x, y, obj) {
	puntero.x = x;
	puntero.y = y;
	if (isDragging && draggedTower) {
		var gameplayBounds = getGameplayBounds();
		var uiBounds = getUIBounds();
		var offset = calculateDragOffset(x, y);
		var targetX = x + offset.offsetX;
		var targetY = y + offset.offsetY;
		// Apply boundary constraints
		if (targetY > uiBounds.top) {
			targetY = uiBounds.top - 70;
		}
		if (targetY < gameplayBounds.top) {
			targetY = gameplayBounds.top + 70;
		}
		if (targetX < uiBounds.left) {
			targetX = uiBounds.left + 70;
		}
		if (targetX > uiBounds.right) {
			targetX = uiBounds.right - 70;
		}
		// Check if tower is too close to existing towers
		var minDistance = 200; // Minimum distance between towers
		var minDistanceSquared = minDistance * minDistance;
		var tooCloseToOtherTowers = false;
		for (var i = 0; i < placedTowers.length; i++) {
			var existingTower = placedTowers[i];
			var dx = targetX - existingTower.x;
			var dy = targetY - existingTower.y;
			var distanceSquared = dx * dx + dy * dy;
			if (distanceSquared < minDistanceSquared) {
				tooCloseToOtherTowers = true;
				break;
			}
		}
		// Update area tint based on pointer position and tower proximity
		var pointerInUI = isPointInUI(puntero.x, puntero.y);
		var cannotPlace = pointerInUI || tooCloseToOtherTowers;
		if (cannotPlace) {
			// Apply red tint to area when cannot place tower
			if (draggedTower.children[0]) {
				draggedTower.children[0].tint = 0xff0000;
			}
		} else {
			// Remove tint from area when tower can be placed
			if (draggedTower.children[0]) {
				draggedTower.children[0].tint = 0xFFFFFF;
			}
		}
		// Smooth movement
		var smoothness = 0.15;
		draggedTower.x += (targetX - draggedTower.x) * smoothness;
		draggedTower.y += (targetY - draggedTower.y) * smoothness;
	}
};
// Game update handler
game.update = function () {
	// No need to update info texts since we removed them
};
// Game release handler
game.up = function (x, y, obj) {
	if (isDragging && draggedTower) {
		var gameplayBounds = getGameplayBounds();
		var uiBounds = getUIBounds();
		var pointerInUI = isPointInUI(puntero.x, puntero.y);
		var towerInUI = draggedTower.x >= uiBounds.left && draggedTower.x <= uiBounds.right && draggedTower.y >= uiBounds.top && draggedTower.y <= uiBounds.bottom;
		if (pointerInUI || towerInUI) {
			draggedTower.destroy();
		} else if (draggedTower.x >= gameplayBounds.left && draggedTower.x <= gameplayBounds.right && draggedTower.y >= gameplayBounds.top && draggedTower.y <= gameplayBounds.bottom) {
			// Check if tower is too close to existing towers
			var minDistance = 200; // Minimum distance between towers
			var minDistanceSquared = minDistance * minDistance;
			var canPlace = true;
			for (var i = 0; i < placedTowers.length; i++) {
				var existingTower = placedTowers[i];
				var dx = draggedTower.x - existingTower.x;
				var dy = draggedTower.y - existingTower.y;
				var distanceSquared = dx * dx + dy * dy;
				if (distanceSquared < minDistanceSquared) {
					canPlace = false;
					break;
				}
			}
			if (canPlace) {
				draggedTower.alpha = 1.0;
				draggedTower.tint = 0xffffff;
				draggedTower.hideRange(); // Hide range area when placed
				draggedTower.isPlaced = true; // Set placement status
				placedTowers.push(draggedTower); // Add to placed towers array
				LK.getSound('TorreColocada').play(); // Play tower placement sound
			} else {
				// Tower is too close to existing towers, destroy it
				draggedTower.destroy();
			}
		} else {
			draggedTower.destroy();
		}
		isDragging = false;
		draggedTower = null;
	}
};

===================================================================
--- original.js
+++ change.js
@@ -216,12 +216,12 @@
 			// Toggle selection for this tower
 			self.isSelected = !self.isSelected;
 			if (self.isSelected) {
 				self.showRange();
-				updateTowerInfo(self); // Update UI with this tower's info
+				updateTowerUpgrade(self); // Update UI with this tower's upgrade options
 			} else {
 				self.hideRange();
-				updateTowerInfo(null); // Clear UI info when deselected
+				updateTowerUpgrade(null); // Clear UI when deselected
 			}
 		};
 		return self;
 	});
@@ -288,9 +288,9 @@
 		for (var i = 0; i < placedTowers.length; i++) {
 			placedTowers[i].isSelected = false;
 			placedTowers[i].hideRange();
 		}
-		updateTowerInfo(null); // Clear tower info when no tower is selected
+		updateTowerUpgrade(null); // Clear tower upgrade when no tower is selected
 	}
 };
 // Helper functions for bounds calculations
 function getGameplayBounds() {
@@ -442,91 +442,91 @@
 enemyTest.updateHealthColor();
 // Enemy is now stationary - no movement code needed
 // UI mode management
 var UI_MODE_TOWER_CREATION = 'creation';
-var UI_MODE_TOWER_INFO = 'info';
+var UI_MODE_TOWER_UPGRADE = 'upgrade';
 var currentUIMode = UI_MODE_TOWER_CREATION;
-// UI Information panel for selected tower
-var towerInfoContainer = game.addChild(new Container());
-// Reposiciona el panel para que esté más centrado y use más espacio horizontal
-towerInfoContainer.x = 1024; // Centrado horizontalmente en la UI
-towerInfoContainer.y = 2250; // Un poco más arriba para aprovechar el espacio
-// Aumenta el tamaño y el ancho de los textos, y distribúyelos en dos columnas de dos filas y el botón de borrar a la derecha
-var infoTextWidth = 500; // Ancho máximo para cada columna de textos
-var leftColX = -800; // X para columna izquierda, más a la izquierda
-var rightColX = -300; // X para columna derecha, también a la izquierda
-var rowY1 = 130;
-var rowY2 = 130 + 120;
-var towerInfoTitle = towerInfoContainer.addChild(new Text2('Tower Info', {
+// UI Upgrade panel for selected tower
+var towerUpgradeContainer = game.addChild(new Container());
+towerUpgradeContainer.x = 1024;
+towerUpgradeContainer.y = 2250;
+var upgradeTitle = towerUpgradeContainer.addChild(new Text2('Upgrade Tower', {
 	size: 100,
-	fill: 0xFFFFFF,
-	wordWrap: true,
-	wordWrapWidth: 1200
+	fill: 0xFFFFFF
 }));
-towerInfoTitle.anchor.set(0, 0);
-towerInfoTitle.x = leftColX;
-towerInfoTitle.y = 0;
-// Primera columna, fila 1: Damage
-var towerDamageText = towerInfoContainer.addChild(new Text2('DMG: --', {
-	size: 80,
-	fill: 0xFFFF00,
-	wordWrap: true,
-	wordWrapWidth: infoTextWidth
+upgradeTitle.anchor.set(0.5, 0);
+upgradeTitle.x = 0;
+upgradeTitle.y = 0;
+// Upgrade damage button
+var upgradeDamageButtonBG = towerUpgradeContainer.addChild(LK.getAsset('BGbuttonTower', {
+	anchorX: 0.5,
+	anchorY: 0.5,
+	scaleX: 1.4,
+	scaleY: 1.4
 }));
-towerDamageText.anchor.set(0, 0);
-towerDamageText.x = leftColX;
-towerDamageText.y = rowY1;
-// Primera columna, fila 2: Range
-var towerRangeText = towerInfoContainer.addChild(new Text2('RNG: --', {
-	size: 80,
-	fill: 0x00FFFF,
-	wordWrap: true,
-	wordWrapWidth: infoTextWidth
+upgradeDamageButtonBG.x = -300;
+upgradeDamageButtonBG.y = 180;
+upgradeDamageButtonBG.tint = 0xFFFF00;
+var upgradeDamageText = towerUpgradeContainer.addChild(new Text2('DMG+', {
+	size: 70,
+	fill: 0x000000
 }));
-towerRangeText.anchor.set(0, 0);
-towerRangeText.x = leftColX;
-towerRangeText.y = rowY2;
-// Segunda columna, fila 1: Fire Rate
-var towerCadenceText = towerInfoContainer.addChild(new Text2('SPD: --', {
-	size: 80,
-	fill: 0x00FF00,
-	wordWrap: true,
-	wordWrapWidth: infoTextWidth
+upgradeDamageText.anchor.set(0.5, 0.5);
+upgradeDamageText.x = -300;
+upgradeDamageText.y = 180;
+// Upgrade speed button
+var upgradeSpeedButtonBG = towerUpgradeContainer.addChild(LK.getAsset('BGbuttonTower', {
+	anchorX: 0.5,
+	anchorY: 0.5,
+	scaleX: 1.4,
+	scaleY: 1.4
 }));
-towerCadenceText.anchor.set(0, 0);
-towerCadenceText.x = rightColX;
-towerCadenceText.y = rowY1;
-// Segunda columna, fila 2: Total Damage
-var towerTotalDamageText = towerInfoContainer.addChild(new Text2('TOT: --', {
-	size: 80,
-	fill: 0xFF00FF,
-	wordWrap: true,
-	wordWrapWidth: infoTextWidth
+upgradeSpeedButtonBG.x = 0;
+upgradeSpeedButtonBG.y = 180;
+upgradeSpeedButtonBG.tint = 0x00FF00;
+var upgradeSpeedText = towerUpgradeContainer.addChild(new Text2('SPD+', {
+	size: 70,
+	fill: 0x000000
 }));
-towerTotalDamageText.anchor.set(0, 0);
-towerTotalDamageText.x = rightColX;
-towerTotalDamageText.y = rowY2;
-// Botón de borrar a la derecha
-var deleteButtonX = 650; // Más a la derecha del panel
-var deleteButtonY = 200; // Centrado verticalmente respecto a los textos
-var deleteTowerButtonBG = towerInfoContainer.addChild(LK.getAsset('BGbuttonTower', {
+upgradeSpeedText.anchor.set(0.5, 0.5);
+upgradeSpeedText.x = 0;
+upgradeSpeedText.y = 180;
+// Upgrade range button
+var upgradeRangeButtonBG = towerUpgradeContainer.addChild(LK.getAsset('BGbuttonTower', {
 	anchorX: 0.5,
 	anchorY: 0.5,
-	scaleX: 1.6,
-	scaleY: 1.6
+	scaleX: 1.4,
+	scaleY: 1.4
 }));
-deleteTowerButtonBG.x = deleteButtonX;
-deleteTowerButtonBG.y = deleteButtonY;
-deleteTowerButtonBG.tint = 0xff0000; // Red background for delete button
-var deleteTowerButtonText = towerInfoContainer.addChild(new Text2('DELETE', {
-	size: 80,
+upgradeRangeButtonBG.x = 300;
+upgradeRangeButtonBG.y = 180;
+upgradeRangeButtonBG.tint = 0x00FFFF;
+var upgradeRangeText = towerUpgradeContainer.addChild(new Text2('RNG+', {
+	size: 70,
+	fill: 0x000000
+}));
+upgradeRangeText.anchor.set(0.5, 0.5);
+upgradeRangeText.x = 300;
+upgradeRangeText.y = 180;
+// Delete button at bottom right of upgrade panel
+var deleteTowerButtonBG = towerUpgradeContainer.addChild(LK.getAsset('BGbuttonTower', {
+	anchorX: 0.5,
+	anchorY: 0.5,
+	scaleX: 1.4,
+	scaleY: 1.4
+}));
+deleteTowerButtonBG.x = 500;
+deleteTowerButtonBG.y = 180;
+deleteTowerButtonBG.tint = 0xff0000;
+var deleteTowerButtonText = towerUpgradeContainer.addChild(new Text2('DEL', {
+	size: 70,
 	fill: 0xFFFFFF
 }));
 deleteTowerButtonText.anchor.set(0.5, 0.5);
-deleteTowerButtonText.x = deleteButtonX;
-deleteTowerButtonText.y = deleteButtonY;
-// Store reference to currently selected tower for deletion
-var selectedTowerForDeletion = null;
+deleteTowerButtonText.x = 500;
+deleteTowerButtonText.y = 180;
+// Store reference to currently selected tower
+var selectedTowerForUpgrade = null;
 // Function to switch UI modes
 function setUIMode(mode) {
 	currentUIMode = mode;
 	if (mode === UI_MODE_TOWER_CREATION) {
@@ -536,62 +536,85 @@
 			if (towerButtons[i].buttonBG) {
 				towerButtons[i].buttonBG.visible = true;
 			}
 		}
-		// Hide tower info panel
-		towerInfoContainer.visible = false;
-	} else if (mode === UI_MODE_TOWER_INFO) {
+		// Hide tower upgrade panel
+		towerUpgradeContainer.visible = false;
+	} else if (mode === UI_MODE_TOWER_UPGRADE) {
 		// Hide tower creation buttons and their backgrounds
 		for (var i = 0; i < towerButtons.length; i++) {
 			towerButtons[i].visible = false;
 			if (towerButtons[i].buttonBG) {
 				towerButtons[i].buttonBG.visible = false;
 			}
 		}
-		// Show tower info panel
-		towerInfoContainer.visible = true;
+		// Show tower upgrade panel
+		towerUpgradeContainer.visible = true;
 	}
 }
-// Function to update tower info display
-function updateTowerInfo(tower) {
+// Function to update tower upgrade display
+function updateTowerUpgrade(tower) {
 	if (tower) {
-		towerDamageText.setText('DMG: ' + tower.damage);
-		towerCadenceText.setText('SPD: ' + (1000 / tower.cadence).toFixed(1) + '/s');
-		towerRangeText.setText('RNG: ' + tower.range);
-		towerTotalDamageText.setText('TOT: ' + tower.totalDamage);
-		// Store reference to selected tower for deletion
-		selectedTowerForDeletion = tower;
-		// Switch to tower info mode when a tower is selected
-		setUIMode(UI_MODE_TOWER_INFO);
+		// Store reference to selected tower for upgrades
+		selectedTowerForUpgrade = tower;
+		// Switch to tower upgrade mode when a tower is selected
+		setUIMode(UI_MODE_TOWER_UPGRADE);
 	} else {
-		towerDamageText.setText('DMG: --');
-		towerCadenceText.setText('SPD: --');
-		towerRangeText.setText('RNG: --');
-		towerTotalDamageText.setText('TOT: --');
 		// Clear reference to selected tower
-		selectedTowerForDeletion = null;
+		selectedTowerForUpgrade = null;
 		// Switch back to tower creation mode when no tower is selected
 		setUIMode(UI_MODE_TOWER_CREATION);
 	}
 }
+// Upgrade damage button click handler
+upgradeDamageButtonBG.down = function (x, y, obj) {
+	if (selectedTowerForUpgrade) {
+		selectedTowerForUpgrade.damage += 1;
+		// Flash button to show upgrade
+		LK.effects.flashObject(upgradeDamageButtonBG, 0xFFFFFF, 300);
+	}
+};
+// Upgrade speed button click handler
+upgradeSpeedButtonBG.down = function (x, y, obj) {
+	if (selectedTowerForUpgrade) {
+		selectedTowerForUpgrade.cadence = Math.max(100, selectedTowerForUpgrade.cadence - 100);
+		// Flash button to show upgrade
+		LK.effects.flashObject(upgradeSpeedButtonBG, 0xFFFFFF, 300);
+	}
+};
+// Upgrade range button click handler
+upgradeRangeButtonBG.down = function (x, y, obj) {
+	if (selectedTowerForUpgrade) {
+		selectedTowerForUpgrade.range += 50;
+		selectedTowerForUpgrade.rangeSquared = selectedTowerForUpgrade.range * selectedTowerForUpgrade.range;
+		// Update the range area scale
+		if (selectedTowerForUpgrade.children[0]) {
+			var areaScale = selectedTowerForUpgrade.range * 2 / 100;
+			selectedTowerForUpgrade.children[0].scaleX = areaScale;
+			selectedTowerForUpgrade.children[0].scaleY = areaScale;
+		}
+		// Flash button to show upgrade
+		LK.effects.flashObject(upgradeRangeButtonBG, 0xFFFFFF, 300);
+	}
+};
 // Delete button click handler
 deleteTowerButtonBG.down = function (x, y, obj) {
-	if (selectedTowerForDeletion) {
+	if (selectedTowerForUpgrade) {
 		// Remove tower from placed towers array
 		for (var i = 0; i < placedTowers.length; i++) {
-			if (placedTowers[i] === selectedTowerForDeletion) {
+			if (placedTowers[i] === selectedTowerForUpgrade) {
 				placedTowers.splice(i, 1);
 				break;
 			}
 		}
 		// Destroy the tower
-		selectedTowerForDeletion.destroy();
-		// Clear tower info and switch back to creation mode
-		updateTowerInfo(null);
+		selectedTowerForUpgrade.destroy();
+		// Clear tower upgrade and switch back to creation mode
+		updateTowerUpgrade(null);
 	}
 };
 // Initialize with no tower selected and tower creation mode
-updateTowerInfo(null);
+updateTowerUpgrade(null);
 setUIMode(UI_MODE_TOWER_CREATION);
 // Top overlay layer (pointer on top of everything)
 var puntero = game.addChild(LK.getAsset('Puntero', {
 	anchorX: 0.5,
@@ -658,12 +681,9 @@
 	}
 };
 // Game update handler
 game.update = function () {
-	// Update tower info display if a tower is selected and info panel is visible
-	if (selectedTowerForDeletion && currentUIMode === UI_MODE_TOWER_INFO) {
-		towerTotalDamageText.setText('TOT: ' + selectedTowerForDeletion.totalDamage);
-	}
+	// No need to update info texts since we removed them
 };
 // Game release handler
 game.up = function (x, y, obj) {
 	if (isDragging && draggedTower) {