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

/**** 
* Classes
****/ 
var AICell = Container.expand(function () {
	var self = Container.call(this);
	var cellGraphics = self.attachAsset('cell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// self.size is set on spawnAICell for variety
	self.speed = 2 + Math.random();
	self.targetX = Math.random() * 8192;
	self.targetY = Math.random() * 8192;
	self.alive = true;
	self.lastX = self.x;
	self.lastY = self.y;
	self.update = function () {
		if (!self.alive) {
			return;
		}
		// Move towards target
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 5) {
			// Speed scales inversely with size: smaller = faster, larger = slower
			var minSpeed = 0.8;
			var maxSpeed = 4.5;
			var baseSize = 50;
			var speed = Math.max(minSpeed, maxSpeed - (self.size - baseSize) / 15);
			self.x += dx / distance * speed;
			self.y += dy / distance * speed;
		} else {
			// Pick new random target
			self.targetX = Math.random() * 14000;
			self.targetY = Math.random() * 14000;
		}
		// Keep within bounds
		if (self.x < self.size / 2) {
			self.x = self.size / 2;
		}
		if (self.x > 14000 - self.size / 2) {
			self.x = 14000 - self.size / 2;
		}
		if (self.y < self.size / 2) {
			self.y = self.size / 2;
		}
		if (self.y > 14000 - self.size / 2) {
			self.y = 14000 - self.size / 2;
		}
		self.lastX = self.x;
		self.lastY = self.y;
	};
	self.grow = function (amount) {
		var oldSize = self.size;
		self.size += amount;
		var scale = self.size / 50;
		tween(cellGraphics, {
			scaleX: scale,
			scaleY: scale
		}, {
			duration: 200,
			easing: tween.easeOut
		});
		self.speed = Math.max(0.8, 2.5 - (self.size - 50) / 60);
	};
	return self;
});
var Food = Container.expand(function () {
	var self = Container.call(this);
	var foodGraphics = self.attachAsset('food', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.size = 20;
	self.consumed = false;
	return self;
});
var PlayerCell = Container.expand(function () {
	var self = Container.call(this);
	var cellGraphics = self.attachAsset('cell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.size = 50;
	self.speed = 3;
	self.targetX = self.x;
	self.targetY = self.y;
	self.grow = function (amount) {
		var oldSize = self.size;
		self.size += amount;
		// Update visual scale
		var scale = self.size / 50;
		tween(cellGraphics, {
			scaleX: scale,
			scaleY: scale
		}, {
			duration: 200,
			easing: tween.easeOut
		});
		// Reduce speed as size increases
		self.speed = Math.max(1, 3 - (self.size - 50) / 50);
		LK.getSound('grow').play();
		LK.setScore(Math.floor(self.size));
	};
	self.update = function () {
		// Slither.io style drag controls: playerCell.targetX/Y is set by drag logic in game.move
		// Move towards target position
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 5) {
			// Speed scales inversely with size: smaller = faster, larger = slower
			var minSpeed = 1.2;
			var maxSpeed = 6;
			var baseSize = 50;
			var speed = Math.max(minSpeed, maxSpeed - (self.size - baseSize) / 18);
			self.x += dx / distance * speed;
			self.y += dy / distance * speed;
		}
		// Keep within bounds
		if (self.x < self.size / 2) {
			self.x = self.size / 2;
		}
		if (self.x > 14000 - self.size / 2) {
			self.x = 14000 - self.size / 2;
		}
		if (self.y < self.size / 2) {
			self.y = self.size / 2;
		}
		if (self.y > 14000 - self.size / 2) {
			self.y = 14000 - self.size / 2;
		}
	};
	return self;
});
var Predator = Container.expand(function () {
	var self = Container.call(this);
	var predatorGraphics = self.attachAsset('predator', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.size = 80;
	self.speed = 1;
	self.targetX = Math.random() * 8192;
	self.targetY = Math.random() * 8192;
	self.update = function () {
		// Move towards target
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 5) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		} else {
			// Pick new random target
			self.targetX = Math.random() * 14000;
			self.targetY = Math.random() * 14000;
		}
		// Chase player if close enough
		if (playerCell) {
			var playerDx = playerCell.x - self.x;
			var playerDy = playerCell.y - self.y;
			var playerDistance = Math.sqrt(playerDx * playerDx + playerDy * playerDy);
			if (playerDistance < 300 && playerCell.size < self.size) {
				self.x += playerDx / playerDistance * self.speed * 1.5;
				self.y += playerDy / playerDistance * self.speed * 1.5;
			}
		}
		// Keep within bounds
		if (self.x < 0) {
			self.x = 0;
		}
		if (self.x > 14000) {
			self.x = 14000;
		}
		if (self.y < 0) {
			self.y = 0;
		}
		if (self.y > 14000) {
			self.y = 14000;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var playerCell = null;
var foods = [];
var predators = [];
var aiCells = [];
var cellsEaten = 0;
// Score display
var scoreTxt = new Text2('Size: 50', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Create a world container for all game objects (slither.io style)
var world = new Container();
game.addChild(world);
// Initialize player cell
playerCell = new PlayerCell();
playerCell.x = 14000 / 2;
playerCell.y = 14000 / 2;
world.addChild(playerCell);
// Generate initial food
function spawnFood() {
	var food = new Food();
	food.x = Math.random() * 14000;
	food.y = Math.random() * 14000;
	foods.push(food);
	world.addChild(food);
}
;
// Generate initial predators
function spawnPredator() {
	var predator = new Predator();
	predator.x = Math.random() * 14000;
	predator.y = Math.random() * 14000;
	predators.push(predator);
	world.addChild(predator);
}
// Generate AI cells
function spawnAICell() {
	var ai = new AICell();
	ai.x = Math.random() * 14000;
	ai.y = Math.random() * 14000;
	// Assign random size: 50, 70, 90, 150, 300, or 1000
	var possibleSizes = [50, 70, 90, 150, 300, 1000];
	var sizeIdx = Math.floor(Math.random() * possibleSizes.length);
	ai.size = possibleSizes[sizeIdx];
	// Update scale to match new size
	var scale = ai.size / 50;
	if (ai.children && ai.children.length > 0) {
		var cellGraphics = ai.children[0];
		cellGraphics.scaleX = scale;
		cellGraphics.scaleY = scale;
	}
	aiCells.push(ai);
	world.addChild(ai);
}
// Spawn initial food
for (var i = 0; i < 2000; i++) {
	spawnFood();
}
// Spawn initial predators
for (var i = 0; i < 5; i++) {
	spawnPredator();
}
// Spawn initial AI cells
for (var i = 0; i < 60; i++) {
	spawnAICell();
}
// Slither.io style swipe/drag controls
var dragging = false;
var dragTouchId = null;
var lastTouchX = null;
var lastTouchY = null;
var dragStartX = null;
var dragStartY = null;
var dragPlayerStartX = null;
var dragPlayerStartY = null;
game.down = function (x, y, obj) {
	// Start dragging from anywhere except top left 100x100
	if (!(x < 100 && y < 100)) {
		dragging = true;
		dragTouchId = obj && obj.event && obj.event.identifier !== undefined ? obj.event.identifier : null;
		dragStartX = x;
		dragStartY = y;
		dragPlayerStartX = playerCell.x;
		dragPlayerStartY = playerCell.y;
		lastTouchX = x;
		lastTouchY = y;
	}
};
game.move = function (x, y, obj) {
	if (dragging && (dragTouchId === null || obj && obj.event && obj.event.identifier === dragTouchId)) {
		lastTouchX = x;
		lastTouchY = y;
		// Calculate drag vector relative to drag start
		var dx = x - dragStartX;
		var dy = y - dragStartY;
		// Set a max drag distance for control sensitivity
		var maxDrag = 400;
		var dragLen = Math.sqrt(dx * dx + dy * dy);
		if (dragLen > maxDrag) {
			dx = dx * maxDrag / dragLen;
			dy = dy * maxDrag / dragLen;
		}
		// Set the target position for the player cell based on drag
		playerCell.targetX = dragPlayerStartX + dx * 8;
		playerCell.targetY = dragPlayerStartY + dy * 8;
	}
};
game.up = function (x, y, obj) {
	if (dragging && (dragTouchId === null || obj && obj.event && obj.event.identifier === dragTouchId)) {
		dragging = false;
		dragTouchId = null;
		lastTouchX = null;
		lastTouchY = null;
		dragStartX = null;
		dragStartY = null;
		dragPlayerStartX = null;
		dragPlayerStartY = null;
	}
};
game.update = function () {
	if (!playerCell) {
		return;
	}
	// Camera logic: center world on playerCell, clamp to map bounds (slither.io style) with zoom
	var viewWidth = 2048;
	var viewHeight = 2732;
	var mapSize = 14000;
	// Camera zoom: smaller player = more zoomed in, larger player = zooms out
	// Clamp zoom between 0.5 (zoomed out) and 1.2 (zoomed in)
	var minZoom = 0.5;
	var maxZoom = 1.2;
	var baseSize = 50;
	var maxSize = 300;
	var zoom = maxZoom - (playerCell.size - baseSize) * (maxZoom - minZoom) / (maxSize - baseSize);
	if (zoom < minZoom) zoom = minZoom;
	if (zoom > maxZoom) zoom = maxZoom;
	// Calculate camera target position to center player, accounting for zoom
	var camTargetX = playerCell.x - viewWidth / 2 / zoom;
	var camTargetY = playerCell.y - viewHeight / 2 / zoom;
	// Clamp camera to map bounds (account for zoom)
	var camMaxX = mapSize - viewWidth / zoom;
	var camMaxY = mapSize - viewHeight / zoom;
	if (camMaxX < 0) camMaxX = 0;
	if (camMaxY < 0) camMaxY = 0;
	camTargetX = Math.max(0, Math.min(camTargetX, camMaxX));
	camTargetY = Math.max(0, Math.min(camTargetY, camMaxY));
	// Smooth camera movement (slither.io style)
	if (typeof world.lastCamX === "undefined") world.lastCamX = camTargetX;
	if (typeof world.lastCamY === "undefined") world.lastCamY = camTargetY;
	world.lastCamX += (camTargetX - world.lastCamX) * 0.15;
	world.lastCamY += (camTargetY - world.lastCamY) * 0.15;
	// Move and scale world container
	world.x = -Math.round(world.lastCamX * zoom);
	world.y = -Math.round(world.lastCamY * zoom);
	world.scaleX = zoom;
	world.scaleY = zoom;
	// AI cells update and logic
	for (var i = aiCells.length - 1; i >= 0; i--) {
		var ai = aiCells[i];
		if (!ai.alive) {
			continue;
		}
		ai.update();
		// AI eats food
		for (var j = foods.length - 1; j >= 0; j--) {
			var food = foods[j];
			if (food.consumed) {
				continue;
			}
			var dx = ai.x - food.x;
			var dy = ai.y - food.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < ai.size / 2 + food.size / 2) {
				food.consumed = true;
				food.destroy();
				foods.splice(j, 1);
				ai.grow(15);
				break;
			}
		}
		// AI eats other AI (io style)
		for (var k = aiCells.length - 1; k >= 0; k--) {
			if (i === k) {
				continue;
			}
			var other = aiCells[k];
			if (!other.alive) {
				continue;
			}
			var dx = ai.x - other.x;
			var dy = ai.y - other.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < ai.size / 2 + other.size / 2) {
				if (ai.size > other.size * 1.2) {
					other.alive = false;
					other.destroy();
					ai.grow(other.size / 2);
					aiCells.splice(k, 1);
					if (k < i) {
						i--;
					} // Adjust index if needed
					break;
				}
			}
		}
		// AI can eat player or be eaten by player
		var dxp = ai.x - playerCell.x;
		var dyp = ai.y - playerCell.y;
		var distp = Math.sqrt(dxp * dxp + dyp * dyp);
		if (distp < ai.size / 2 + playerCell.size / 2) {
			if (ai.size > playerCell.size * 1.2) {
				// Player is eaten by a larger AI cell
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
				return;
			} else if (playerCell.size > ai.size * 1.2) {
				// Player eats smaller AI cell
				ai.alive = false;
				ai.destroy();
				aiCells.splice(i, 1);
				playerCell.grow(ai.size / 2);
				cellsEaten++;
				LK.getSound('eat').play();
				scoreTxt.setText('Size: ' + Math.floor(playerCell.size) + ' | Eaten: ' + cellsEaten);
				break;
			}
		}
	}
	// Check food collisions for player
	for (var i = foods.length - 1; i >= 0; i--) {
		var food = foods[i];
		if (food.consumed) {
			continue;
		}
		var dx = playerCell.x - food.x;
		var dy = playerCell.y - food.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < playerCell.size / 2 + food.size / 2) {
			// Consume food
			food.consumed = true;
			food.destroy();
			foods.splice(i, 1);
			playerCell.grow(15);
			// Do not increment cellsEaten for food
			LK.getSound('eat').play();
			// Update score display
			// Do not update cellsEaten for food, only show size
			scoreTxt.setText('Size: ' + Math.floor(playerCell.size));
		}
	}
	// Check predator collisions
	for (var i = 0; i < predators.length; i++) {
		var predator = predators[i];
		var dx = playerCell.x - predator.x;
		var dy = playerCell.y - predator.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < playerCell.size / 2 + predator.size / 2) {
			if (predator.size > playerCell.size) {
				// Game over - eaten by predator
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
				return;
			} else if (playerCell.size > predator.size * 1.2) {
				// Player can eat predator
				predator.destroy();
				predators.splice(i, 1);
				playerCell.grow(20);
				cellsEaten++;
				LK.getSound('eat').play();
				scoreTxt.setText('Size: ' + Math.floor(playerCell.size) + ' | Eaten: ' + cellsEaten);
				// Spawn new predator
				spawnPredator();
				i--; // Adjust index after removal
			}
		}
	}
	// Spawn new food periodically
	if (LK.ticks % 2 == 0 && foods.length < 2000) {
		spawnFood();
	}
	// Add more predators as player grows
	if (LK.ticks % 600 == 0 && predators.length < 8) {
		spawnPredator();
	}
	// Add more AI cells as the game progresses
	if (LK.ticks % 300 == 0 && aiCells.length < 12) {
		spawnAICell();
	}
	// Win condition - reach size 300
	if (playerCell.size >= 300) {
		LK.showYouWin();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -165,12 +165,10 @@
 		// Chase player if close enough
 		if (playerCell) {
 			var playerDx = playerCell.x - self.x;
 			var playerDy = playerCell.y - self.y;
-			var playerDistanceSquared = playerDx * playerDx + playerDy * playerDy;
-			if (playerDistanceSquared < 90000 && playerCell.size < self.size) {
-				// 300 * 300 = 90000
-				var playerDistance = Math.sqrt(playerDistanceSquared);
+			var playerDistance = Math.sqrt(playerDx * playerDx + playerDy * playerDy);
+			if (playerDistance < 300 && playerCell.size < self.size) {
 				self.x += playerDx / playerDistance * self.speed * 1.5;
 				self.y += playerDy / playerDistance * self.speed * 1.5;
 			}
 		}
@@ -358,23 +356,14 @@
 	world.x = -Math.round(world.lastCamX * zoom);
 	world.y = -Math.round(world.lastCamY * zoom);
 	world.scaleX = zoom;
 	world.scaleY = zoom;
-	// AI cells update and logic with culling
-	var cullDistance = 1500; // Only update AI cells within this distance
-	var cullDistanceSquared = cullDistance * cullDistance;
+	// AI cells update and logic
 	for (var i = aiCells.length - 1; i >= 0; i--) {
 		var ai = aiCells[i];
 		if (!ai.alive) {
 			continue;
 		}
-		// Cull distant AI cells for performance
-		var aiDx = ai.x - playerCell.x;
-		var aiDy = ai.y - playerCell.y;
-		var aiDistanceSquared = aiDx * aiDx + aiDy * aiDy;
-		if (aiDistanceSquared > cullDistanceSquared) {
-			continue; // Skip updating distant AI cells
-		}
 		ai.update();
 		// AI eats food
 		for (var j = foods.length - 1; j >= 0; j--) {
 			var food = foods[j];
@@ -382,15 +371,14 @@
 				continue;
 			}
 			var dx = ai.x - food.x;
 			var dy = ai.y - food.y;
-			var distanceSquared = dx * dx + dy * dy;
-			var collisionRadius = ai.size / 2 + food.size / 2;
-			if (distanceSquared < collisionRadius * collisionRadius) {
+			var distance = Math.sqrt(dx * dx + dy * dy);
+			if (distance < ai.size / 2 + food.size / 2) {
 				food.consumed = true;
 				food.destroy();
 				foods.splice(j, 1);
-				ai.grow(5);
+				ai.grow(15);
 				break;
 			}
 		}
 		// AI eats other AI (io style)
@@ -403,11 +391,10 @@
 				continue;
 			}
 			var dx = ai.x - other.x;
 			var dy = ai.y - other.y;
-			var distanceSquared = dx * dx + dy * dy;
-			var collisionRadius = ai.size / 2 + other.size / 2;
-			if (distanceSquared < collisionRadius * collisionRadius) {
+			var distance = Math.sqrt(dx * dx + dy * dy);
+			if (distance < ai.size / 2 + other.size / 2) {
 				if (ai.size > other.size * 1.2) {
 					other.alive = false;
 					other.destroy();
 					ai.grow(other.size / 2);
@@ -421,11 +408,10 @@
 		}
 		// AI can eat player or be eaten by player
 		var dxp = ai.x - playerCell.x;
 		var dyp = ai.y - playerCell.y;
-		var distpSquared = dxp * dxp + dyp * dyp;
-		var collisionRadius = ai.size / 2 + playerCell.size / 2;
-		if (distpSquared < collisionRadius * collisionRadius) {
+		var distp = Math.sqrt(dxp * dxp + dyp * dyp);
+		if (distp < ai.size / 2 + playerCell.size / 2) {
 			if (ai.size > playerCell.size * 1.2) {
 				// Player is eaten by a larger AI cell
 				LK.effects.flashScreen(0xff0000, 1000);
 				LK.showGameOver();
@@ -442,30 +428,23 @@
 				break;
 			}
 		}
 	}
-	// Check food collisions for player with culling
-	var foodCullDistance = 800; // Only check food within this distance
-	var foodCullDistanceSquared = foodCullDistance * foodCullDistance;
+	// Check food collisions for player
 	for (var i = foods.length - 1; i >= 0; i--) {
 		var food = foods[i];
 		if (food.consumed) {
 			continue;
 		}
-		// Quick distance check for culling
-		var foodDx = playerCell.x - food.x;
-		var foodDy = playerCell.y - food.y;
-		var foodDistanceSquared = foodDx * foodDx + foodDy * foodDy;
-		if (foodDistanceSquared > foodCullDistanceSquared) {
-			continue; // Skip distant food
-		}
-		var collisionRadius = playerCell.size / 2 + food.size / 2;
-		if (foodDistanceSquared < collisionRadius * collisionRadius) {
+		var dx = playerCell.x - food.x;
+		var dy = playerCell.y - food.y;
+		var distance = Math.sqrt(dx * dx + dy * dy);
+		if (distance < playerCell.size / 2 + food.size / 2) {
 			// Consume food
 			food.consumed = true;
 			food.destroy();
 			foods.splice(i, 1);
-			playerCell.grow(5);
+			playerCell.grow(15);
 			// Do not increment cellsEaten for food
 			LK.getSound('eat').play();
 			// Update score display
 			// Do not update cellsEaten for food, only show size
@@ -476,11 +455,10 @@
 	for (var i = 0; i < predators.length; i++) {
 		var predator = predators[i];
 		var dx = playerCell.x - predator.x;
 		var dy = playerCell.y - predator.y;
-		var distanceSquared = dx * dx + dy * dy;
-		var collisionRadius = playerCell.size / 2 + predator.size / 2;
-		if (distanceSquared < collisionRadius * collisionRadius) {
+		var distance = Math.sqrt(dx * dx + dy * dy);
+		if (distance < playerCell.size / 2 + predator.size / 2) {
 			if (predator.size > playerCell.size) {
 				// Game over - eaten by predator
 				LK.effects.flashScreen(0xff0000, 1000);
 				LK.showGameOver();