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

/**** 
* Classes
****/ 
// Energy orb class
var EnergyOrb = Container.expand(function () {
	var self = Container.call(this);
	self.radius = 40;
	self.asset = self.attachAsset('energyOrb', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: self.radius * 2,
		height: self.radius * 2
	});
	self.setPosition = function (x, y) {
		self.x = x;
		self.y = y;
	};
	return self;
});
// Player class (for both self and others)
var Player = Container.expand(function () {
	var self = Container.call(this);
	// Default properties
	self.radius = 80; // initial radius
	self.isSelf = false;
	self.id = null;
	self.cooldown = 0; // ms
	self.lastBlink = -9999; // timestamp
	self.visionRadius = 500; // px, will scale with size
	self.score = 0;
	// Attach asset
	self.asset = null; // will be set in init
	self.setIsSelf = function (isSelf) {
		self.isSelf = isSelf;
		if (self.asset) self.removeChild(self.asset);
		self.asset = self.attachAsset(isSelf ? 'playerSelf' : 'playerOther', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: self.radius * 2,
			height: self.radius * 2
		});
		// Remove vision mask if switching to not self
		if (!isSelf && self.visionMask && self.visionMask.parent) {
			self.visionMask.parent.removeChild(self.visionMask);
			self.visionMask = null;
		}
	};
	self.setRadius = function (r) {
		self.radius = r;
		if (self.asset) {
			self.asset.width = r * 2;
			self.asset.height = r * 2;
		}
		// Vision radius scales with size
		self.visionRadius = Math.max(500, r * 3);
	};
	self.grow = function (amount) {
		var newRadius = Math.min(400, self.radius + amount);
		if (newRadius > 400) newRadius = 400;
		self.setRadius(newRadius);
	};
	self.shrink = function (amount) {
		var newRadius = Math.max(40, self.radius - amount);
		if (newRadius < 40) newRadius = 40;
		self.setRadius(newRadius);
	};
	// For blinking effect
	self.blinkTo = function (x, y) {
		// Blink trail effect: draw a neon line from old position to new position
		var oldX = self.x;
		var oldY = self.y;
		// Clamp to world bounds before moving
		var clamped = clampToWorld(x, y, self.radius);
		// Move to new position
		self.x = clamped.x;
		self.y = clamped.y;
		self.lastBlink = Date.now();
		self.cooldown = 500; // ms
		// Neon flash
		tween(self.asset, {
			alpha: 0.3
		}, {
			duration: 80,
			onFinish: function onFinish() {
				tween(self.asset, {
					alpha: 1
				}, {
					duration: 120
				});
			}
		});
		// Draw blink trail (neon line)
		var trail = LK.getAsset(self.isSelf ? 'playerSelf' : 'playerOther', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: dist(oldX, oldY, x, y),
			height: 16
		});
		// Set color based on player type
		if (self.isSelf) {
			trail.tint = 0x00ffff;
		} else {
			trail.tint = 0xff00cc;
		}
		trail.alpha = 0.7;
		// Position at midpoint
		trail.x = (oldX + x) / 2;
		trail.y = (oldY + y) / 2;
		// Rotate to match direction
		trail.rotation = Math.atan2(y - oldY, x - oldX);
		// Add to parent
		if (self.parent) self.parent.addChild(trail);
		// Animate fade out and destroy
		tween(trail, {
			alpha: 0
		}, {
			duration: 180,
			onFinish: function onFinish() {
				if (trail && trail.destroy) trail.destroy();
			}
		});
	};
	// For vision mask (only for self)
	self.visionMask = null;
	self.updateVisionMask = function () {
		if (!self.isSelf) return;
		if (!self.visionMask) {
			self.visionMask = LK.getAsset('playerSelf', {
				anchorX: 0.5,
				anchorY: 0.5,
				width: self.visionRadius * 2,
				height: self.visionRadius * 2
			});
			self.visionMask.alpha = 0.18;
			self.visionMask.tint = 0x00ffff;
			// Remove if already present
			if (self.visionMask.parent) self.visionMask.parent.removeChild(self.visionMask);
			if (self.parent) {
				// Always add vision mask below player
				var idx = self.parent.getChildIndex(self);
				self.parent.addChildAt(self.visionMask, Math.max(0, idx));
			}
		}
		if (self.visionMask) {
			self.visionMask.x = self.x;
			self.visionMask.y = self.y;
			self.visionMask.width = self.visionRadius * 2;
			self.visionMask.height = self.visionRadius * 2;
		}
	};
	// For update
	self.update = function () {
		if (self.cooldown > 0) {
			var elapsed = Date.now() - self.lastBlink;
			self.cooldown = Math.max(0, 500 - elapsed);
		}
		if (self.isSelf) {
			self.updateVisionMask();
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Player (neon blue), Other players (neon pink), Energy orb (neon green)
// Neon colored player circles, energy orbs, and a black background
// World size (start with a large value, but will expand infinitely)
var WORLD_WIDTH = 3000;
var WORLD_HEIGHT = 3000;
// Expand world size every minute to simulate infinite map
var worldExpandInterval = LK.setInterval(function () {
	// Expand by 2000px in each direction every minute
	WORLD_WIDTH += 2000;
	WORLD_HEIGHT += 2000;
	// Reposition all players and orbs to remain within new bounds if needed
	for (var i = 0; i < players.length; i++) {
		var p = players[i];
		var clamped = clampToWorld(p.x, p.y, p.radius);
		p.x = clamped.x;
		p.y = clamped.y;
	}
	for (var i = 0; i < orbs.length; i++) {
		var orb = orbs[i];
		var clamped = clampToWorld(orb.x, orb.y, orb.radius);
		orb.x = clamped.x;
		orb.y = clamped.y;
		if (orb.glow) {
			orb.glow.x = orb.x;
			orb.glow.y = orb.y;
		}
	}
}, 60000);
// Players
var players = [];
var selfPlayer = null;
var selfId = 'self'; // In real multiplayer, this would be unique
// Energy orbs
var orbs = [];
var MAX_ORBS = 20;
// Camera offset (for centering self)
var camOffsetX = 0;
var camOffsetY = 0;
// Score text
var scoreTxt = new Text2('0', {
	size: 100,
	fill: 0x00FFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Bot count text
var botCountTxt = new Text2('', {
	size: 60,
	fill: 0xFF00CC
});
botCountTxt.anchor.set(0.5, 0);
botCountTxt.y = 60;
LK.gui.top.addChild(botCountTxt);
// Cooldown text
var cooldownTxt = new Text2('', {
	size: 60,
	fill: 0xFFFFFF
});
cooldownTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(cooldownTxt);
cooldownTxt.y = 120;
// Helper: distance between two points
function dist(ax, ay, bx, by) {
	var dx = ax - bx;
	var dy = ay - by;
	return Math.sqrt(dx * dx + dy * dy);
}
// Helper: clamp to world bounds (uses current WORLD_WIDTH/HEIGHT)
function clampToWorld(x, y, r) {
	x = Math.max(r, Math.min(WORLD_WIDTH - r, x));
	y = Math.max(r, Math.min(WORLD_HEIGHT - r, y));
	return {
		x: x,
		y: y
	};
}
// Helper: random position in world (uses current WORLD_WIDTH/HEIGHT)
function randomWorldPos(r) {
	return {
		x: r + Math.random() * (WORLD_WIDTH - 2 * r),
		y: r + Math.random() * (WORLD_HEIGHT - 2 * r)
	};
}
// Create self player
selfPlayer = new Player();
selfPlayer.id = selfId;
selfPlayer.setIsSelf(true);
var startPos = randomWorldPos(selfPlayer.radius);
selfPlayer.x = startPos.x;
selfPlayer.y = startPos.y;
game.addChild(selfPlayer);
players.push(selfPlayer);
// Create some fake other players (for MVP, 3 bots)
for (var i = 0; i < 3; i++) {
	var bot = new Player();
	bot.id = 'bot' + i;
	bot.setIsSelf(false);
	var pos = randomWorldPos(bot.radius);
	bot.x = pos.x;
	bot.y = pos.y;
	// Randomize size
	bot.setRadius(60 + Math.random() * 80);
	game.addChild(bot);
	players.push(bot);
}
// Create energy orbs
function spawnOrb() {
	var orb = new EnergyOrb();
	var tries = 0;
	var pos;
	do {
		pos = randomWorldPos(orb.radius);
		var tooClose = false;
		for (var i = 0; i < players.length; i++) {
			var p = players[i];
			if (dist(pos.x, pos.y, p.x, p.y) < orb.radius + p.radius + 20) {
				tooClose = true;
				break;
			}
		}
		tries++;
	} while (tooClose && tries < 30); // Try more times for safety
	if (!tooClose) {
		orb.setPosition(pos.x, pos.y);
		// Neon glow effect: add a larger, faint ellipse behind the orb
		var glow = LK.getAsset('energyOrb', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: orb.radius * 3,
			height: orb.radius * 3
		});
		glow.alpha = 0.18;
		glow.tint = 0x39ff14;
		glow.x = orb.x;
		glow.y = orb.y;
		game.addChild(glow);
		orb.glow = glow;
		game.addChild(orb);
		orbs.push(orb);
	} else {
		// Fallback: don't spawn if can't find a spot
		orb.destroy();
	}
}
for (var i = 0; i < MAX_ORBS; i++) {
	spawnOrb();
}
// Camera update
function updateCamera() {
	// Center camera on selfPlayer, but clamp so world edges are not empty
	var viewW = 2048;
	var viewH = 2732;
	camOffsetX = Math.max(0, Math.min(WORLD_WIDTH - viewW, selfPlayer.x - viewW / 2));
	camOffsetY = Math.max(0, Math.min(WORLD_HEIGHT - viewH, selfPlayer.y - viewH / 2));
	// Move all game children accordingly
	for (var i = 0; i < game.children.length; i++) {
		var obj = game.children[i];
		obj.visible = true;
		// Only show if within vision
		if (obj === selfPlayer) {
			obj.x = selfPlayer.x - camOffsetX;
			obj.y = selfPlayer.y - camOffsetY;
		} else if (obj instanceof Player) {
			// Only show if within vision radius
			var d = dist(selfPlayer.x, selfPlayer.y, obj.x, obj.y);
			if (d < selfPlayer.visionRadius + obj.radius) {
				obj.visible = true;
				obj.x = obj.x - camOffsetX;
				obj.y = obj.y - camOffsetY;
			} else {
				obj.visible = false;
			}
		} else if (obj instanceof EnergyOrb) {
			var d = dist(selfPlayer.x, selfPlayer.y, obj.x, obj.y);
			if (d < selfPlayer.visionRadius + obj.radius) {
				obj.visible = true;
				obj.x = obj.x - camOffsetX;
				obj.y = obj.y - camOffsetY;
			} else {
				obj.visible = false;
			}
		} else if (obj === selfPlayer.visionMask) {
			obj.x = selfPlayer.x - camOffsetX;
			obj.y = selfPlayer.y - camOffsetY;
			obj.width = selfPlayer.visionRadius * 2;
			obj.height = selfPlayer.visionRadius * 2;
			obj.visible = true;
		}
	}
}
// Only allow movement by blinking (touch/click to blink)
game.down = function (x, y, obj) {
	// Only allow blink if cooldown is 0
	if (selfPlayer.cooldown > 0) return;
	// Convert screen to world coordinates
	var worldX = x + camOffsetX;
	var worldY = y + camOffsetY;
	// Clamp to world only (no vision radius clamp)
	var clamped = clampToWorld(worldX, worldY, selfPlayer.radius);
	// Prevent blinking on top of another player
	for (var i = 0; i < players.length; i++) {
		var p = players[i];
		if (p === selfPlayer) continue;
		var d2 = dist(clamped.x, clamped.y, p.x, p.y);
		if (d2 < selfPlayer.radius + p.radius) {
			// Too close to another player, do not blink
			return;
		}
	}
	selfPlayer.blinkTo(clamped.x, clamped.y);
};
game.up = function (x, y, obj) {
	// No-op
};
game.move = function (x, y, obj) {
	// No-op
};
// WASD/arrow key blink support (desktop only, ignored on mobile)
// WASD/arrow key blink support removed for compatibility with sandbox (window.addEventListener is not available)
// Main update loop
game.update = function () {
	// Update cooldown
	selfPlayer.update();
	// Update bots (smarter AI: chase orb, chase smaller player, avoid bigger player)
	for (var i = 0; i < players.length; i++) {
		var p = players[i];
		if (p === selfPlayer) continue;
		if (p.cooldown <= 0) {
			// Find nearest orb
			var nearestOrb = null;
			var minOrbDist = 99999;
			for (var oi = 0; oi < orbs.length; oi++) {
				var orb = orbs[oi];
				var d = dist(p.x, p.y, orb.x, orb.y);
				if (d < minOrbDist) {
					minOrbDist = d;
					nearestOrb = orb;
				}
			}
			// Find nearest player (other than self)
			var nearestPlayer = null;
			var minPlayerDist = 99999;
			for (var pi = 0; pi < players.length; pi++) {
				var op = players[pi];
				if (op === p) continue;
				var d = dist(p.x, p.y, op.x, op.y);
				if (d < minPlayerDist) {
					minPlayerDist = d;
					nearestPlayer = op;
				}
			}
			var targetX = p.x,
				targetY = p.y;
			var action = "random";
			// If there is a bigger player nearby, avoid!
			var avoid = false;
			for (var pi = 0; pi < players.length; pi++) {
				var op = players[pi];
				if (op === p) continue;
				if (op.radius > p.radius + 8) {
					var d = dist(p.x, p.y, op.x, op.y);
					if (d < p.visionRadius * 0.7) {
						// Flee from this player
						avoid = true;
						// Move away from op
						var fleeAngle = Math.atan2(p.y - op.y, p.x - op.x);
						var fleeDist = p.visionRadius * 0.7;
						targetX = p.x + Math.cos(fleeAngle) * fleeDist;
						targetY = p.y + Math.sin(fleeAngle) * fleeDist;
						action = "flee";
						break;
					}
				}
			}
			if (!avoid) {
				// If there is a smaller player nearby, chase!
				if (nearestPlayer && p.radius > nearestPlayer.radius + 8 && minPlayerDist < p.visionRadius * 0.8) {
					targetX = nearestPlayer.x;
					targetY = nearestPlayer.y;
					action = "chase";
				} else if (nearestOrb && minOrbDist < p.visionRadius * 0.95) {
					// Otherwise, go for nearest orb
					targetX = nearestOrb.x;
					targetY = nearestOrb.y;
					action = "orb";
				} else {
					// Random blink within vision
					var angle = Math.random() * Math.PI * 2;
					var distR = Math.random() * (p.visionRadius - p.radius);
					targetX = p.x + Math.cos(angle) * distR;
					targetY = p.y + Math.sin(angle) * distR;
					action = "random";
				}
			}
			// Clamp to world
			var clamped = clampToWorld(targetX, targetY, p.radius);
			// Clamp to vision
			var d = dist(p.x, p.y, clamped.x, clamped.y);
			if (d > p.visionRadius - p.radius) {
				var angle = Math.atan2(clamped.y - p.y, clamped.x - p.x);
				clamped.x = p.x + Math.cos(angle) * (p.visionRadius - p.radius);
				clamped.y = p.y + Math.sin(angle) * (p.visionRadius - p.radius);
			}
			// --- AI improvement: avoid blinking too close to other players (including self) ---
			var safe = true;
			for (var ai = 0; ai < players.length; ai++) {
				var other = players[ai];
				if (other === p) continue;
				// Don't blink if too close to another player
				var minDist = p.radius + other.radius + 10;
				if (dist(clamped.x, clamped.y, other.x, other.y) < minDist) {
					safe = false;
					break;
				}
			}
			// If not safe, try to blink to a random safe spot within vision
			if (!safe) {
				var found = false;
				for (var tries = 0; tries < 8 && !found; tries++) {
					var angle = Math.random() * Math.PI * 2;
					var distR = Math.random() * (p.visionRadius - p.radius);
					var rx = p.x + Math.cos(angle) * distR;
					var ry = p.y + Math.sin(angle) * distR;
					var rclamp = clampToWorld(rx, ry, p.radius);
					var ok = true;
					for (var ai2 = 0; ai2 < players.length; ai2++) {
						var other2 = players[ai2];
						if (other2 === p) continue;
						var minDist2 = p.radius + other2.radius + 10;
						if (dist(rclamp.x, rclamp.y, other2.x, other2.y) < minDist2) {
							ok = false;
							break;
						}
					}
					if (ok) {
						clamped = rclamp;
						found = true;
					}
				}
				// If still not found, stay in place
				if (!found) {
					clamped.x = p.x;
					clamped.y = p.y;
				}
			}
			// --- AI improvement: prefer orbs not near bigger players ---
			if (action === "orb" && nearestOrb) {
				var danger = false;
				for (var ai3 = 0; ai3 < players.length; ai3++) {
					var op3 = players[ai3];
					if (op3 === p) continue;
					if (op3.radius > p.radius + 8) {
						var d3 = dist(nearestOrb.x, nearestOrb.y, op3.x, op3.y);
						if (d3 < op3.visionRadius * 0.5) {
							danger = true;
							break;
						}
					}
				}
				if (danger) {
					// Pick a random safe spot instead
					var found2 = false;
					for (var tries2 = 0; tries2 < 8 && !found2; tries2++) {
						var angle2 = Math.random() * Math.PI * 2;
						var distR2 = Math.random() * (p.visionRadius - p.radius);
						var rx2 = p.x + Math.cos(angle2) * distR2;
						var ry2 = p.y + Math.sin(angle2) * distR2;
						var rclamp2 = clampToWorld(rx2, ry2, p.radius);
						var ok2 = true;
						for (var ai4 = 0; ai4 < players.length; ai4++) {
							var other4 = players[ai4];
							if (other4 === p) continue;
							var minDist4 = p.radius + other4.radius + 10;
							if (dist(rclamp2.x, rclamp2.y, other4.x, other4.y) < minDist4) {
								ok2 = false;
								break;
							}
						}
						if (ok2) {
							clamped = rclamp2;
							found2 = true;
						}
					}
					if (!found2) {
						clamped.x = p.x;
						clamped.y = p.y;
					}
				}
			}
			p.blinkTo(clamped.x, clamped.y);
		}
		p.update();
	}
	// Energy orb collection
	for (var i = orbs.length - 1; i >= 0; i--) {
		var orb = orbs[i];
		// Only check if visible
		if (!orb.visible) continue;
		// Make sure glow follows orb
		if (orb.glow) {
			orb.glow.x = orb.x;
			orb.glow.y = orb.y;
			orb.glow.visible = orb.visible;
		}
		for (var j = 0; j < players.length; j++) {
			var p = players[j];
			var dx = (p === selfPlayer ? selfPlayer.x : p.x) - orb.x;
			var dy = (p === selfPlayer ? selfPlayer.y : p.y) - orb.y;
			var d = Math.sqrt(dx * dx + dy * dy);
			if (d < p.radius + orb.radius) {
				// Collect
				p.grow(12);
				if (p === selfPlayer) {
					selfPlayer.score += 1;
					scoreTxt.setText(selfPlayer.score);
				}
				if (orb.glow && orb.glow.destroy) orb.glow.destroy();
				orb.destroy();
				orbs.splice(i, 1);
				// Spawn new orb
				spawnOrb();
				break;
			}
		}
	}
	// Player vs player collision
	for (var i = 0; i < players.length; i++) {
		var p1 = players[i];
		for (var j = i + 1; j < players.length; j++) {
			var p2 = players[j];
			// Only check if both are visible to self
			if (!p1.visible && !p2.visible) continue;
			var dx = p1.x - p2.x;
			var dy = p1.y - p2.y;
			var d = Math.sqrt(dx * dx + dy * dy);
			if (d < p1.radius + p2.radius) {
				// Only trigger if at least one just blinked (to avoid constant collision)
				var blinked = Date.now() - p1.lastBlink < 500 || Date.now() - p2.lastBlink < 500;
				if (!blinked) continue;
				// If sizes are different, bigger eats smaller
				if (Math.abs(p1.radius - p2.radius) > 2) {
					var bigger, smaller;
					if (p1.radius > p2.radius) {
						bigger = p1;
						smaller = p2;
					} else {
						bigger = p2;
						smaller = p1;
					}
					bigger.grow(smaller.radius * 0.4);
					if (smaller === selfPlayer) {
						// Flash red, game over
						LK.effects.flashScreen(0xff0033, 800);
						LK.showGameOver();
						return;
					} else {
						// Remove bot
						if (players.indexOf(smaller) !== -1) {
							smaller.destroy();
							players.splice(players.indexOf(smaller), 1);
							// Only remove one player per collision
							break;
						}
					}
				} else {
					// Same size: both shrink
					p1.shrink(p1.radius * 0.3);
					p2.shrink(p2.radius * 0.3);
					// Flash both
					LK.effects.flashObject(p1, 0xffffff, 300);
					LK.effects.flashObject(p2, 0xffffff, 300);
				}
			}
		}
	}
	// Win condition: reach size
	if (selfPlayer.radius >= 300) {
		LK.showYouWin();
		return;
	}
	// Update camera
	updateCamera();
	// Update UI
	scoreTxt.setText(selfPlayer.score);
	// Count bots (players that are not selfPlayer)
	var botCount = 0;
	for (var i = 0; i < players.length; i++) {
		if (players[i] !== selfPlayer) botCount++;
	}
	botCountTxt.setText('Botlar: ' + botCount);
	if (selfPlayer.cooldown > 0) {
		cooldownTxt.setText('Blink: ' + (Math.ceil(selfPlayer.cooldown / 100) / 10).toFixed(1) + 's');
	} else {
		cooldownTxt.setText('Blink ready!');
	}
};

===================================================================
--- original.js
+++ change.js
@@ -177,11 +177,34 @@
 * Game Code
 ****/ 
 // Player (neon blue), Other players (neon pink), Energy orb (neon green)
 // Neon colored player circles, energy orbs, and a black background
-// World size (bigger than screen for .io feel)
+// World size (start with a large value, but will expand infinitely)
 var WORLD_WIDTH = 3000;
 var WORLD_HEIGHT = 3000;
+// Expand world size every minute to simulate infinite map
+var worldExpandInterval = LK.setInterval(function () {
+	// Expand by 2000px in each direction every minute
+	WORLD_WIDTH += 2000;
+	WORLD_HEIGHT += 2000;
+	// Reposition all players and orbs to remain within new bounds if needed
+	for (var i = 0; i < players.length; i++) {
+		var p = players[i];
+		var clamped = clampToWorld(p.x, p.y, p.radius);
+		p.x = clamped.x;
+		p.y = clamped.y;
+	}
+	for (var i = 0; i < orbs.length; i++) {
+		var orb = orbs[i];
+		var clamped = clampToWorld(orb.x, orb.y, orb.radius);
+		orb.x = clamped.x;
+		orb.y = clamped.y;
+		if (orb.glow) {
+			orb.glow.x = orb.x;
+			orb.glow.y = orb.y;
+		}
+	}
+}, 60000);
 // Players
 var players = [];
 var selfPlayer = null;
 var selfId = 'self'; // In real multiplayer, this would be unique
@@ -219,18 +242,18 @@
 	var dx = ax - bx;
 	var dy = ay - by;
 	return Math.sqrt(dx * dx + dy * dy);
 }
-// Helper: clamp to world bounds
+// Helper: clamp to world bounds (uses current WORLD_WIDTH/HEIGHT)
 function clampToWorld(x, y, r) {
 	x = Math.max(r, Math.min(WORLD_WIDTH - r, x));
 	y = Math.max(r, Math.min(WORLD_HEIGHT - r, y));
 	return {
 		x: x,
 		y: y
 	};
 }
-// Helper: random position in world
+// Helper: random position in world (uses current WORLD_WIDTH/HEIGHT)
 function randomWorldPos(r) {
 	return {
 		x: r + Math.random() * (WORLD_WIDTH - 2 * r),
 		y: r + Math.random() * (WORLD_HEIGHT - 2 * r)