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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function (startX, startY, targetX, targetY, damage, faction) {
	var self = Container.call(this);
	self.x = startX;
	self.y = startY;
	self.damage = damage;
	self.faction = faction;
	self.speed = 8;
	var dx = targetX - startX;
	var dy = targetY - startY;
	var distance = Math.sqrt(dx * dx + dy * dy);
	self.velocityX = dx / distance * self.speed;
	self.velocityY = dy / distance * self.speed;
	self.maxDistance = distance;
	self.traveled = 0;
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		self.traveled += self.speed;
		// Check if bullet reached target area or max distance
		if (self.traveled >= self.maxDistance) {
			self.explode();
		}
	};
	self.explode = function () {
		// Find units in explosion radius
		var explosionRadius = 30;
		for (var i = 0; i < allUnits.length; i++) {
			var unit = allUnits[i];
			if (unit.faction !== self.faction && unit.health > 0) {
				var dx = unit.x - self.x;
				var dy = unit.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < explosionRadius) {
					var destroyed = unit.takeDamage(self.damage);
					if (destroyed) {
						LK.getSound('explosion').play();
					}
				}
			}
		}
		// Check cities
		var enemyCities = self.faction === 'red' ? blueCities : redCities;
		for (var i = 0; i < enemyCities.length; i++) {
			var city = enemyCities[i];
			if (city.health > 0) {
				var dx = city.x - self.x;
				var dy = city.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < explosionRadius) {
					var destroyed = city.takeDamage(self.damage);
					if (destroyed) {
						LK.getSound('explosion').play();
					}
				}
			}
		}
		// Remove bullet
		for (var i = 0; i < bullets.length; i++) {
			if (bullets[i] === self) {
				bullets.splice(i, 1);
				break;
			}
		}
		self.destroy();
	};
	return self;
});
var City = Container.expand(function (faction) {
	var self = Container.call(this);
	self.faction = faction;
	self.health = 1000;
	self.maxHealth = 1000;
	self.lastProduction = 0;
	self.productionCooldown = 180; // 3 seconds at 60fps
	var cityGraphics = self.attachAsset('city', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Color based on faction
	if (faction === 'red') {
		cityGraphics.tint = 0xff4444;
	} else {
		cityGraphics.tint = 0x4444ff;
	}
	// Health bar background
	var healthBarBg = self.attachAsset('healthBarBg', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -50
	});
	// Health bar
	var healthBar = self.attachAsset('healthBar', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -50
	});
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.health = 0;
			return true; // City destroyed
		}
		// Update health bar
		var healthPercent = self.health / self.maxHealth;
		healthBar.width = 80 * healthPercent;
		return false;
	};
	self.produceUnit = function () {
		if (LK.ticks - self.lastProduction < self.productionCooldown) return;
		// Choose random unit type
		var unitTypes = ['infantry', 'tank', 'artillery'];
		var unitType = unitTypes[Math.floor(Math.random() * unitTypes.length)];
		var unit = new Unit(unitType, self.faction);
		// Position near city
		unit.x = self.x + (Math.random() - 0.5) * 100;
		unit.y = self.y + (Math.random() - 0.5) * 100;
		// Keep within bounds
		unit.x = Math.max(50, Math.min(1998, unit.x));
		unit.y = Math.max(50, Math.min(2682, unit.y));
		allUnits.push(unit);
		game.addChild(unit);
		self.lastProduction = LK.ticks;
	};
	self.update = function () {
		if (self.health <= 0) return;
		self.produceUnit();
	};
	return self;
});
var Unit = Container.expand(function (type, faction) {
	var self = Container.call(this);
	self.type = type;
	self.faction = faction;
	self.target = null;
	self.lastShot = 0;
	self.health = 100;
	self.maxHealth = 100;
	self.moveSpeed = 2;
	self.range = 100;
	self.damage = 20;
	self.shootCooldown = 60;
	// Set unit stats based on type
	if (type === 'infantry') {
		self.moveSpeed = 1.5;
		self.health = 60;
		self.maxHealth = 60;
		self.damage = 15;
		self.range = 80;
		self.shootCooldown = 40;
	} else if (type === 'tank') {
		self.moveSpeed = 3;
		self.health = 120;
		self.maxHealth = 120;
		self.damage = 30;
		self.range = 100;
		self.shootCooldown = 60;
	} else if (type === 'artillery') {
		self.moveSpeed = 1;
		self.health = 80;
		self.maxHealth = 80;
		self.damage = 50;
		self.range = 180;
		self.shootCooldown = 90;
	}
	var unitGraphics = self.attachAsset(type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Color based on faction
	if (faction === 'red') {
		unitGraphics.tint = 0xff4444;
	} else {
		unitGraphics.tint = 0x4444ff;
	}
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.health = 0;
			return true; // Unit destroyed
		}
		return false;
	};
	self.findTarget = function () {
		var closestDistance = Infinity;
		var closestTarget = null;
		// Find closest enemy unit
		for (var i = 0; i < allUnits.length; i++) {
			var unit = allUnits[i];
			if (unit.faction !== self.faction && unit.health > 0) {
				var dx = unit.x - self.x;
				var dy = unit.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < closestDistance) {
					closestDistance = distance;
					closestTarget = unit;
				}
			}
		}
		// Check enemy cities
		var enemyCities = self.faction === 'red' ? blueCities : redCities;
		for (var i = 0; i < enemyCities.length; i++) {
			var city = enemyCities[i];
			if (city.health > 0) {
				var dx = city.x - self.x;
				var dy = city.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < closestDistance) {
					closestDistance = distance;
					closestTarget = city;
				}
			}
		}
		return closestTarget;
	};
	self.update = function () {
		if (self.health <= 0) return;
		self.target = self.findTarget();
		if (self.target && self.target.health > 0) {
			var dx = self.target.x - self.x;
			var dy = self.target.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > self.range) {
				// Move towards target
				var angle = Math.atan2(dy, dx);
				self.x += Math.cos(angle) * self.moveSpeed;
				self.y += Math.sin(angle) * self.moveSpeed;
				// Keep units within bounds
				self.x = Math.max(50, Math.min(1998, self.x));
				self.y = Math.max(50, Math.min(2682, self.y));
			} else {
				// In range, shoot
				if (LK.ticks - self.lastShot > self.shootCooldown) {
					self.shoot();
					self.lastShot = LK.ticks;
				}
			}
		}
		// Check territory conversion when unit touches territorial squares
		for (var i = 0; i < territorialGrid.length; i++) {
			var territorySquare = territorialGrid[i];
			if (self.intersects(territorySquare)) {
				// Convert territory square to unit's faction color
				if (self.faction === 'red') {
					territorySquare.tint = 0xff4444;
				} else {
					territorySquare.tint = 0x4444ff;
				}
			}
		}
	};
	self.shoot = function () {
		if (!self.target || self.target.health <= 0) return;
		var bullet = new Bullet(self.x, self.y, self.target.x, self.target.y, self.damage, self.faction);
		bullets.push(bullet);
		game.addChild(bullet);
		LK.getSound('shoot').play();
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state
var allUnits = [];
var bullets = [];
var redCities = [];
var blueCities = [];
var gameStarted = false;
var territorialGrid = [];
// UI
var statusText = new Text2('Europa 1941: AI War', {
	size: 40,
	fill: 0xFFFFFF
});
statusText.anchor.set(0.5, 0);
LK.gui.top.addChild(statusText);
var redScoreText = new Text2('Red Cities: 0', {
	size: 30,
	fill: 0xFF4444
});
redScoreText.anchor.set(0, 0);
redScoreText.x = 20;
redScoreText.y = 120;
LK.gui.top.addChild(redScoreText);
var blueScoreText = new Text2('Blue Cities: 0', {
	size: 30,
	fill: 0x4444FF
});
blueScoreText.anchor.set(1, 0);
blueScoreText.x = -20;
blueScoreText.y = 50;
LK.gui.topRight.addChild(blueScoreText);
// Initialize cities
function initializeCities() {
	var minDistance = 120; // Minimum distance between cities
	// Red cities (left side)
	for (var i = 0; i < 5; i++) {
		var city = new City('red');
		var attempts = 0;
		var maxAttempts = 50;
		var validPosition = false;
		while (!validPosition && attempts < maxAttempts) {
			city.x = 150 + Math.random() * 500; // Random x between 150-650
			city.y = 200 + Math.random() * 2300; // Random y between 200-2500
			validPosition = true;
			// Check distance from other red cities
			for (var j = 0; j < redCities.length; j++) {
				var dx = city.x - redCities[j].x;
				var dy = city.y - redCities[j].y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < minDistance) {
					validPosition = false;
					break;
				}
				;
			}
			attempts++;
		}
		redCities.push(city);
		game.addChild(city);
	}
	// Blue cities (right side)
	for (var i = 0; i < 5; i++) {
		var city = new City('blue');
		var attempts = 0;
		var maxAttempts = 50;
		var validPosition = false;
		while (!validPosition && attempts < maxAttempts) {
			city.x = 1400 + Math.random() * 500; // Random x between 1400-1900
			city.y = 200 + Math.random() * 2300; // Random y between 200-2500
			validPosition = true;
			// Check distance from other blue cities
			for (var j = 0; j < blueCities.length; j++) {
				var dx = city.x - blueCities[j].x;
				var dy = city.y - blueCities[j].y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < minDistance) {
					validPosition = false;
					break;
				}
			}
			attempts++;
		}
		blueCities.push(city);
		game.addChild(city);
	}
}
function updateUI() {
	var redAlive = 0;
	var blueAlive = 0;
	var previousRedAlive = 0;
	var previousBlueAlive = 0;
	// Count previous alive cities
	for (var i = 0; i < redCities.length; i++) {
		if (redCities[i].health > 0) {
			redAlive++;
		} else if (redCities[i].health === 0) {
			// Check if this was just destroyed
			previousRedAlive++;
		}
	}
	for (var i = 0; i < blueCities.length; i++) {
		if (blueCities[i].health > 0) {
			blueAlive++;
		} else if (blueCities[i].health === 0) {
			// Check if this was just destroyed
			previousBlueAlive++;
		}
	}
	// Update territorial grid when cities are destroyed
	var totalCitiesNow = redAlive + blueAlive;
	var totalCitiesBefore = redCities.length + blueCities.length;
	if (totalCitiesNow < totalCitiesBefore) {
		createTerritorialGrid();
	}
	redScoreText.setText('Red Cities: ' + redAlive);
	blueScoreText.setText('Blue Cities: ' + blueAlive);
	// Check win conditions
	if (redAlive === 0) {
		statusText.setText('Blue AI Wins!');
		LK.showYouWin();
	} else if (blueAlive === 0) {
		statusText.setText('Red AI Wins!');
		LK.showYouWin();
	}
}
function createTerritorialGrid() {
	// Clear existing grid
	for (var i = 0; i < territorialGrid.length; i++) {
		territorialGrid[i].destroy();
	}
	territorialGrid = [];
	var gridSize = 80; // Same size as cities
	var rows = Math.floor(2732 / gridSize);
	var cols = Math.floor(2048 / gridSize);
	for (var row = 0; row < rows; row++) {
		for (var col = 0; col < cols; col++) {
			var x = col * gridSize + gridSize / 2;
			var y = row * gridSize + gridSize / 2;
			// Determine territory based on closest surviving city
			var closestRedDistance = Infinity;
			var closestBlueDistance = Infinity;
			// Check red cities
			for (var i = 0; i < redCities.length; i++) {
				if (redCities[i].health > 0) {
					var dx = x - redCities[i].x;
					var dy = y - redCities[i].y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < closestRedDistance) {
						closestRedDistance = distance;
					}
				}
			}
			// Check blue cities
			for (var i = 0; i < blueCities.length; i++) {
				if (blueCities[i].health > 0) {
					var dx = x - blueCities[i].x;
					var dy = y - blueCities[i].y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < closestBlueDistance) {
						closestBlueDistance = distance;
					}
				}
			}
			// Create territory square
			var territorySquare = LK.getAsset('territory', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			territorySquare.x = x;
			territorySquare.y = y;
			territorySquare.alpha = 0.6;
			// Color based on closest territory
			if (closestRedDistance < closestBlueDistance) {
				territorySquare.tint = 0xff4444;
			} else {
				territorySquare.tint = 0x4444ff;
			}
			territorialGrid.push(territorySquare);
			game.addChild(territorySquare);
			// Add pulsing effect to make colors more visible
			tween(territorySquare, {
				alpha: 0.3
			}, 2000);
		}
	}
}
function cleanupDeadUnits() {
	for (var i = allUnits.length - 1; i >= 0; i--) {
		if (allUnits[i].health <= 0) {
			allUnits[i].destroy();
			allUnits.splice(i, 1);
		}
	}
}
// Start game
LK.setTimeout(function () {
	initializeCities();
	createTerritorialGrid();
	gameStarted = true;
	statusText.setText('Battle in Progress...');
}, 1000);
// Game update loop
game.update = function () {
	if (!gameStarted) return;
	// Update all units
	for (var i = 0; i < allUnits.length; i++) {
		if (allUnits[i].health > 0) {
			allUnits[i].update();
		}
	}
	// Update all cities
	for (var i = 0; i < redCities.length; i++) {
		redCities[i].update();
	}
	for (var i = 0; i < blueCities.length; i++) {
		blueCities[i].update();
	}
	// Update all bullets
	for (var i = 0; i < bullets.length; i++) {
		bullets[i].update();
	}
	// Cleanup dead units
	cleanupDeadUnits();
	// Update UI
	updateUI();
};

===================================================================
--- original.js
+++ change.js
@@ -331,8 +331,9 @@
 				if (distance < minDistance) {
 					validPosition = false;
 					break;
 				}
+				;
 			}
 			attempts++;
 		}
 		redCities.push(city);
@@ -457,12 +458,11 @@
 			}
 			territorialGrid.push(territorySquare);
 			game.addChild(territorySquare);
 			// Add pulsing effect to make colors more visible
-			tween.to(territorySquare, 2000, {
-				alpha: 0.3,
-				ease: tween.easeInOut
-			});
+			tween(territorySquare, {
+				alpha: 0.3
+			}, 2000);
 		}
 	}
 }
 function cleanupDeadUnits() {