===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,422 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1");
+
+/**** 
+* Classes
+****/ 
+var PathLine = Container.expand(function () {
+	var self = Container.call(this);
+	self.points = [];
+	self.graphics = [];
+	self.setPath = function (points) {
+		// Clear old graphics
+		for (var i = 0; i < self.graphics.length; i++) {
+			self.graphics[i].destroy();
+		}
+		self.graphics = [];
+		self.points = points;
+		// Draw new path
+		for (var i = 0; i < points.length - 1; i++) {
+			var dist = Math.sqrt(Math.pow(points[i + 1].x - points[i].x, 2) + Math.pow(points[i + 1].y - points[i].y, 2));
+			var segments = Math.floor(dist / 20);
+			for (var j = 0; j < segments; j++) {
+				var t = j / segments;
+				var dot = self.attachAsset('path', {
+					anchorX: 0.5,
+					anchorY: 0.5
+				});
+				dot.x = points[i].x + (points[i + 1].x - points[i].x) * t;
+				dot.y = points[i].y + (points[i + 1].y - points[i].y) * t;
+				dot.alpha = 0.5;
+				self.graphics.push(dot);
+			}
+		}
+	};
+	self.clear = function () {
+		for (var i = 0; i < self.graphics.length; i++) {
+			self.graphics[i].destroy();
+		}
+		self.graphics = [];
+		self.points = [];
+	};
+	return self;
+});
+var Tower = Container.expand(function () {
+	var self = Container.call(this);
+	self.owner = 0; // 0 = neutral, 1 = player, 2 = enemy
+	self.unitCount = 0;
+	self.maxUnits = 50;
+	self.spawnRate = 30; // ticks between spawns
+	self.lastSpawn = 0;
+	var towerGraphics = self.attachAsset('tower', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.countText = new Text2('0', {
+		size: 60,
+		fill: 0xFFFFFF
+	});
+	self.countText.anchor.set(0.5, 0.5);
+	self.addChild(self.countText);
+	self.setOwner = function (newOwner) {
+		self.owner = newOwner;
+		if (newOwner === 0) {
+			towerGraphics.tint = 0x888888; // neutral gray
+		} else if (newOwner === 1) {
+			towerGraphics.tint = 0x4a90e2; // player blue
+		} else {
+			towerGraphics.tint = 0xe74c3c; // enemy red
+		}
+	};
+	self.addUnits = function (count) {
+		self.unitCount = Math.min(self.unitCount + count, self.maxUnits);
+		self.countText.setText(Math.floor(self.unitCount));
+	};
+	self.removeUnits = function (count) {
+		self.unitCount = Math.max(0, self.unitCount - count);
+		self.countText.setText(Math.floor(self.unitCount));
+		return count;
+	};
+	self.update = function () {
+		if (self.owner > 0 && LK.ticks - self.lastSpawn > self.spawnRate) {
+			self.addUnits(1);
+			self.lastSpawn = LK.ticks;
+		}
+	};
+	return self;
+});
+var Unit = Container.expand(function () {
+	var self = Container.call(this);
+	self.owner = 1;
+	self.speed = 3;
+	self.targetTower = null;
+	self.pathIndex = 0;
+	self.path = [];
+	var unitGraphics = self.attachAsset('unit', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.setOwner = function (owner) {
+		self.owner = owner;
+		if (owner === 1) {
+			unitGraphics.tint = 0x4a90e2; // player blue
+		} else {
+			unitGraphics.tint = 0xe74c3c; // enemy red
+		}
+	};
+	self.setPath = function (path, target) {
+		self.path = path;
+		self.targetTower = target;
+		self.pathIndex = 0;
+		if (path.length > 0) {
+			self.x = path[0].x;
+			self.y = path[0].y;
+		}
+	};
+	self.update = function () {
+		if (!self.targetTower || self.pathIndex >= self.path.length) {
+			return;
+		}
+		var target = self.path[self.pathIndex];
+		var dx = target.x - self.x;
+		var dy = target.y - self.y;
+		var dist = Math.sqrt(dx * dx + dy * dy);
+		if (dist < self.speed) {
+			self.pathIndex++;
+			if (self.pathIndex >= self.path.length && self.targetTower) {
+				// Reached target tower
+				if (self.targetTower.owner === self.owner) {
+					self.targetTower.addUnits(1);
+				} else {
+					self.targetTower.unitCount--;
+					if (self.targetTower.unitCount < 0) {
+						self.targetTower.unitCount = 1;
+						self.targetTower.setOwner(self.owner);
+						LK.getSound('capture').play();
+					}
+					self.targetTower.countText.setText(Math.floor(Math.abs(self.targetTower.unitCount)));
+				}
+				self.destroy();
+				units.splice(units.indexOf(self), 1);
+			}
+		} else {
+			self.x += dx / dist * self.speed;
+			self.y += dy / dist * self.speed;
+		}
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x1a1a1a
+});
+
+/**** 
+* Game Code
+****/ 
+var towers = [];
+var units = [];
+var currentPath = null;
+var selectedTower = null;
+var isDragging = false;
+var currentLevel = storage.currentLevel || 0;
+// Level configurations
+var levels = [{
+	towers: [{
+		x: 300,
+		y: 1366,
+		owner: 1,
+		units: 20
+	}, {
+		x: 1024,
+		y: 800,
+		owner: 0,
+		units: 10
+	}, {
+		x: 1748,
+		y: 1366,
+		owner: 2,
+		units: 20
+	}]
+}, {
+	towers: [{
+		x: 300,
+		y: 400,
+		owner: 1,
+		units: 25
+	}, {
+		x: 1024,
+		y: 1366,
+		owner: 0,
+		units: 15
+	}, {
+		x: 1748,
+		y: 400,
+		owner: 2,
+		units: 20
+	}, {
+		x: 1748,
+		y: 2332,
+		owner: 2,
+		units: 20
+	}]
+}, {
+	towers: [{
+		x: 300,
+		y: 1366,
+		owner: 1,
+		units: 30
+	}, {
+		x: 700,
+		y: 800,
+		owner: 0,
+		units: 10
+	}, {
+		x: 1348,
+		y: 800,
+		owner: 0,
+		units: 10
+	}, {
+		x: 700,
+		y: 1932,
+		owner: 0,
+		units: 10
+	}, {
+		x: 1348,
+		y: 1932,
+		owner: 0,
+		units: 10
+	}, {
+		x: 1748,
+		y: 1366,
+		owner: 2,
+		units: 30
+	}]
+}];
+// UI Elements
+var levelText = new Text2('Level ' + (currentLevel + 1), {
+	size: 80,
+	fill: 0xFFFFFF
+});
+levelText.anchor.set(0.5, 0);
+LK.gui.top.addChild(levelText);
+function loadLevel(levelIndex) {
+	// Clear existing game objects
+	for (var i = 0; i < towers.length; i++) {
+		towers[i].destroy();
+	}
+	for (var i = 0; i < units.length; i++) {
+		units[i].destroy();
+	}
+	towers = [];
+	units = [];
+	if (currentPath) {
+		currentPath.destroy();
+		currentPath = null;
+	}
+	// Load new level
+	var levelData = levels[levelIndex % levels.length];
+	for (var i = 0; i < levelData.towers.length; i++) {
+		var towerData = levelData.towers[i];
+		var tower = new Tower();
+		tower.x = towerData.x;
+		tower.y = towerData.y;
+		tower.setOwner(towerData.owner);
+		tower.addUnits(towerData.units);
+		towers.push(tower);
+		game.addChild(tower);
+	}
+	levelText.setText('Level ' + (levelIndex + 1));
+}
+function createPath(start, end) {
+	var points = [];
+	var steps = 20;
+	for (var i = 0; i <= steps; i++) {
+		points.push({
+			x: start.x + (end.x - start.x) * (i / steps),
+			y: start.y + (end.y - start.y) * (i / steps)
+		});
+	}
+	return points;
+}
+function sendUnits(fromTower, toTower, count) {
+	var path = createPath(fromTower, toTower);
+	var unitsToSend = Math.min(count, fromTower.unitCount);
+	for (var i = 0; i < unitsToSend; i++) {
+		var unit = new Unit();
+		unit.setOwner(fromTower.owner);
+		unit.setPath(path, toTower);
+		units.push(unit);
+		game.addChild(unit);
+		// Stagger unit spawning
+		tween(unit, {
+			x: path[0].x,
+			y: path[0].y
+		}, {
+			duration: i * 50,
+			onFinish: function onFinish() {
+				LK.getSound('deploy').play();
+			}
+		});
+	}
+	fromTower.removeUnits(unitsToSend);
+}
+function checkWinCondition() {
+	var playerTowers = 0;
+	var enemyTowers = 0;
+	for (var i = 0; i < towers.length; i++) {
+		if (towers[i].owner === 1) playerTowers++;
+		if (towers[i].owner === 2) enemyTowers++;
+	}
+	if (enemyTowers === 0) {
+		// Win condition
+		currentLevel++;
+		storage.currentLevel = currentLevel;
+		LK.showYouWin();
+	} else if (playerTowers === 0) {
+		// Lose condition
+		LK.showGameOver();
+	}
+}
+// Simple AI
+function runAI() {
+	for (var i = 0; i < towers.length; i++) {
+		var tower = towers[i];
+		if (tower.owner === 2 && tower.unitCount > 15) {
+			// Find nearest non-enemy tower
+			var nearestTower = null;
+			var nearestDist = Infinity;
+			for (var j = 0; j < towers.length; j++) {
+				if (towers[j].owner !== 2) {
+					var dx = towers[j].x - tower.x;
+					var dy = towers[j].y - tower.y;
+					var dist = Math.sqrt(dx * dx + dy * dy);
+					if (dist < nearestDist) {
+						nearestDist = dist;
+						nearestTower = towers[j];
+					}
+				}
+			}
+			if (nearestTower) {
+				sendUnits(tower, nearestTower, Math.floor(tower.unitCount * 0.8));
+			}
+		}
+	}
+}
+game.down = function (x, y, obj) {
+	// Find if we clicked on a player tower
+	for (var i = 0; i < towers.length; i++) {
+		var tower = towers[i];
+		if (tower.owner === 1 && Math.abs(tower.x - x) < 75 && Math.abs(tower.y - y) < 75) {
+			selectedTower = tower;
+			isDragging = true;
+			if (!currentPath) {
+				currentPath = new PathLine();
+				game.addChild(currentPath);
+			}
+			currentPath.setPath([{
+				x: tower.x,
+				y: tower.y
+			}]);
+			break;
+		}
+	}
+};
+game.move = function (x, y, obj) {
+	if (isDragging && selectedTower && currentPath) {
+		currentPath.setPath([{
+			x: selectedTower.x,
+			y: selectedTower.y
+		}, {
+			x: x,
+			y: y
+		}]);
+	}
+};
+game.up = function (x, y, obj) {
+	if (isDragging && selectedTower) {
+		// Find target tower
+		var targetTower = null;
+		for (var i = 0; i < towers.length; i++) {
+			var tower = towers[i];
+			if (tower !== selectedTower && Math.abs(tower.x - x) < 75 && Math.abs(tower.y - y) < 75) {
+				targetTower = tower;
+				break;
+			}
+		}
+		if (targetTower && selectedTower.unitCount > 0) {
+			sendUnits(selectedTower, targetTower, Math.floor(selectedTower.unitCount * 0.8));
+		}
+		if (currentPath) {
+			currentPath.clear();
+		}
+	}
+	isDragging = false;
+	selectedTower = null;
+};
+game.update = function () {
+	// Update all units
+	for (var i = units.length - 1; i >= 0; i--) {
+		if (!units[i] || !units[i].parent) {
+			units.splice(i, 1);
+		}
+	}
+	// Run AI every 2 seconds
+	if (LK.ticks % 120 === 0) {
+		runAI();
+	}
+	// Check win/lose conditions
+	if (LK.ticks % 60 === 0) {
+		checkWinCondition();
+	}
+};
+// Initialize first level
+loadLevel(currentLevel);
+// Play background music
+LK.playMusic('battle');
\ No newline at end of file