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

/**** 
* Classes
****/ 
// Enemy Cell Class
var EnemyCell = Container.expand(function () {
	var self = Container.call(this);
	var cell = self.attachAsset('enemyCell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = cell.width / 2;
	self.setSize = function (diameter) {
		cell.width = diameter;
		cell.height = diameter;
		self.radius = diameter / 2;
	};
	// AI movement target
	self.targetX = self.x;
	self.targetY = self.y;
	self.speed = (3 + 40 / (self.radius + 40)) * 0.3; // 70% slower movement for enemies
	self.update = function () {
		// Move towards target
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist > self.speed) {
			self.x += dx / dist * self.speed;
			self.y += dy / dist * self.speed;
		} else {
			self.x = self.targetX;
			self.y = self.targetY;
		}
	};
	return self;
});
// Food Cell Class
var FoodCell = Container.expand(function () {
	var self = Container.call(this);
	var cell = self.attachAsset('foodCell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = cell.width / 2;
	self.setSize = function (diameter) {
		cell.width = diameter;
		cell.height = diameter;
		self.radius = diameter / 2;
	};
	return self;
});
// Player Cell Class
var PlayerCell = Container.expand(function () {
	var self = Container.call(this);
	var cell = self.attachAsset('playerCell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = cell.width / 2;
	self.setSize = function (diameter) {
		cell.width = diameter;
		cell.height = diameter;
		self.radius = diameter / 2;
	};
	// For smooth movement
	self.targetX = self.x;
	self.targetY = self.y;
	self.update = function () {
		// Drag direction control: move in drag direction if dragging
		var speed = 4 + 40 / (self.radius + 40); // Slower movement for player, larger cells move slower
		if (typeof dragDirX !== "undefined" && (dragDirX !== 0 || dragDirY !== 0)) {
			// Move in drag direction
			self.x += dragDirX * speed;
			self.y += dragDirY * speed;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Food cell: yellow ellipse
// Enemy cell: blue ellipse
// Player cell: green ellipse
// Arena size (expanded for a much larger play area)
var ARENA_WIDTH = 4096;
var ARENA_HEIGHT = 5464;
// Player cell
var player = new PlayerCell();
player.setSize(180);
player.x = ARENA_WIDTH / 2;
player.y = ARENA_HEIGHT / 2;
game.addChild(player);
// Arrays for enemies and food
var enemies = [];
var foods = [];
// Score display
var score = 0;
var scoreTxt = new Text2('Score: 0', {
	size: 90,
	fill: 0x222222
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Helper: spawn food at random position
function spawnFood() {
	var food = new FoodCell();
	var size = 60 + Math.floor(Math.random() * 40);
	food.setSize(size);
	food.x = 100 + Math.random() * (ARENA_WIDTH - 200);
	food.y = 200 + Math.random() * (ARENA_HEIGHT - 400);
	foods.push(food);
	game.addChild(food);
}
// Helper: spawn enemy at random position and size
function spawnEnemy() {
	var enemy = new EnemyCell();
	var size = 120 + Math.floor(Math.random() * 120);
	enemy.setSize(size);
	// Avoid spawning too close to player
	var safe = false;
	while (!safe) {
		enemy.x = 100 + Math.random() * (ARENA_WIDTH - 200);
		enemy.y = 200 + Math.random() * (ARENA_HEIGHT - 400);
		var dx = enemy.x - player.x;
		var dy = enemy.y - player.y;
		if (Math.sqrt(dx * dx + dy * dy) > 400) safe = true;
	}
	// Set initial AI target
	enemy.targetX = enemy.x;
	enemy.targetY = enemy.y;
	enemies.push(enemy);
	game.addChild(enemy);
}
// Initial spawn
for (var i = 0; i < 18; i++) spawnFood();
for (var i = 0; i < 7; i++) spawnEnemy();
// Drag-to-move: swipe direction controls player movement
var dragging = false;
var dragStartX = 0;
var dragStartY = 0;
var dragLastX = 0;
var dragLastY = 0;
var dragDirX = 0;
var dragDirY = 0;
function clamp(val, min, max) {
	return Math.max(min, Math.min(max, val));
}
game.down = function (x, y, obj) {
	dragging = true;
	dragStartX = x;
	dragStartY = y;
	dragLastX = x;
	dragLastY = y;
	dragDirX = 0;
	dragDirY = 0;
};
game.move = function (x, y, obj) {
	if (dragging) {
		// Calculate drag direction vector
		dragDirX = x - dragStartX;
		dragDirY = y - dragStartY;
		dragLastX = x;
		dragLastY = y;
		// Normalize direction for smooth control
		var len = Math.sqrt(dragDirX * dragDirX + dragDirY * dragDirY);
		if (len > 20) {
			// Only if drag is significant
			dragDirX /= len;
			dragDirY /= len;
		} else {
			dragDirX = 0;
			dragDirY = 0;
		}
	}
};
game.up = function (x, y, obj) {
	dragging = false;
	// Do not reset dragDirX/dragDirY here; keep last direction for inertia
};
// Main update loop
game.update = function () {
	// Update player
	player.update();
	// Update enemies
	for (var i = 0; i < enemies.length; i++) {
		var enemy = enemies[i];
		// AI: If player is smaller, chase; if bigger, flee; else random walk
		var dx = player.x - enemy.x;
		var dy = player.y - enemy.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (enemy.radius > player.radius * 1.15) {
			// Enemy is bigger: chase player if not too close to border
			if (dist < 900) {
				// Move towards player
				enemy.targetX = clamp(player.x, enemy.radius, ARENA_WIDTH - enemy.radius);
				enemy.targetY = clamp(player.y, enemy.radius, ARENA_HEIGHT - enemy.radius);
			} else {
				// Random walk
				if (LK.ticks % 120 === 0) {
					enemy.targetX = 100 + Math.random() * (ARENA_WIDTH - 200);
					enemy.targetY = 200 + Math.random() * (ARENA_HEIGHT - 400);
				}
			}
		} else if (enemy.radius < player.radius * 0.85) {
			// Enemy is smaller: flee from player
			if (dist < 700) {
				var angle = Math.atan2(dy, dx) + Math.PI; // Opposite direction
				var fleeDist = 300;
				enemy.targetX = clamp(enemy.x + Math.cos(angle) * fleeDist, enemy.radius, ARENA_WIDTH - enemy.radius);
				enemy.targetY = clamp(enemy.y + Math.sin(angle) * fleeDist, enemy.radius, ARENA_HEIGHT - enemy.radius);
			} else {
				// Random walk
				if (LK.ticks % 120 === 0) {
					enemy.targetX = 100 + Math.random() * (ARENA_WIDTH - 200);
					enemy.targetY = 200 + Math.random() * (ARENA_HEIGHT - 400);
				}
			}
		} else {
			// Similar size: random walk
			if (LK.ticks % 120 === 0) {
				enemy.targetX = 100 + Math.random() * (ARENA_WIDTH - 200);
				enemy.targetY = 200 + Math.random() * (ARENA_HEIGHT - 400);
			}
		}
		enemy.update();
	}
	// --- Collision: Player eats food ---
	for (var i = foods.length - 1; i >= 0; i--) {
		var food = foods[i];
		var dx = player.x - food.x;
		var dy = player.y - food.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist < player.radius + food.radius * 0.7) {
			// Eat food: grow player by a fixed amount
			var growAmount = Math.max(12, food.radius * 0.6);
			var newDiameter = player.radius * 2 + growAmount;
			newDiameter = Math.min(newDiameter, 600); // Cap max size
			player.setSize(newDiameter);
			// Score
			score += 1;
			scoreTxt.setText('Score: ' + score);
			// Remove food
			food.destroy();
			foods.splice(i, 1);
			// Spawn new food
			spawnFood();
		}
	}
	// --- Collision: Enemy eats food ---
	for (var j = 0; j < enemies.length; j++) {
		var enemy = enemies[j];
		for (var i = foods.length - 1; i >= 0; i--) {
			var food = foods[i];
			var dx = enemy.x - food.x;
			var dy = enemy.y - food.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist < enemy.radius + food.radius * 0.7) {
				// Enemy eats food
				var newSize = Math.min(enemy.radius * 2 + 12, 400);
				enemy.setSize(newSize);
				food.destroy();
				foods.splice(i, 1);
				spawnFood();
			}
		}
	}
	// --- Collision: Player eats enemy or is eaten ---
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		var dx = player.x - enemy.x;
		var dy = player.y - enemy.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist < player.radius + enemy.radius * 0.7) {
			if (player.radius > enemy.radius * 1.15) {
				// Player eats enemy
				var newSize = Math.min(player.radius * 2 + enemy.radius * 2 * 0.7, 700);
				player.setSize(newSize);
				score += 5;
				scoreTxt.setText('Score: ' + score);
				enemy.destroy();
				enemies.splice(i, 1);
				spawnEnemy();
			} else if (enemy.radius > player.radius * 1.15) {
				// Player is eaten
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
				return;
			}
		}
	}
	// --- Enemy eats enemy ---
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemyA = enemies[i];
		for (var j = enemies.length - 1; j >= 0; j--) {
			if (i === j) continue;
			var enemyB = enemies[j];
			var dx = enemyA.x - enemyB.x;
			var dy = enemyA.y - enemyB.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist < enemyA.radius + enemyB.radius * 0.7) {
				if (enemyA.radius > enemyB.radius * 1.15) {
					// A eats B
					var newSize = Math.min(enemyA.radius * 2 + enemyB.radius * 2 * 0.5, 500);
					enemyA.setSize(newSize);
					enemyB.destroy();
					enemies.splice(j, 1);
					spawnEnemy();
					if (j < i) i--; // Adjust index if needed
				}
			}
		}
	}
	// Clamp player inside arena
	player.x = clamp(player.x, player.radius, ARENA_WIDTH - player.radius);
	player.y = clamp(player.y, player.radius, ARENA_HEIGHT - player.radius);
	// Clamp enemies inside arena
	for (var i = 0; i < enemies.length; i++) {
		var enemy = enemies[i];
		enemy.x = clamp(enemy.x, enemy.radius, ARENA_WIDTH - enemy.radius);
		enemy.y = clamp(enemy.y, enemy.radius, ARENA_HEIGHT - enemy.radius);
	}
	// Camera follow: center the visible area on the player
	// LK.stage is the root container for all game objects
	// The visible area is 2048x2732 (game resolution)
	var camX = clamp(player.x, 1024, ARENA_WIDTH - 1024);
	var camY = clamp(player.y, 1366, ARENA_HEIGHT - 1366);
	game.x = 1024 - camX;
	game.y = 1366 - camY;
};

===================================================================
--- original.js
+++ change.js
@@ -75,16 +75,8 @@
 		if (typeof dragDirX !== "undefined" && (dragDirX !== 0 || dragDirY !== 0)) {
 			// Move in drag direction
 			self.x += dragDirX * speed;
 			self.y += dragDirY * speed;
-			// If not dragging, apply friction to slow down
-			if (!dragging) {
-				dragDirX *= 0.93;
-				dragDirY *= 0.93;
-				// Stop completely if very slow
-				if (Math.abs(dragDirX) < 0.01) dragDirX = 0;
-				if (Math.abs(dragDirY) < 0.01) dragDirY = 0;
-			}
 		}
 	};
 	return self;
 });