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

/**** 
* Classes
****/ 
var AntSwarm = Container.expand(function () {
	var self = Container.call(this);
	// Create individual ants in the swarm
	self.ants = [];
	var antCount = 15;
	for (var i = 0; i < antCount; i++) {
		var ant = self.attachAsset('beetle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		ant.tint = 0x8B0000; // Dark red color for poisonous ants
		ant.x = Math.random() * 200 - 100; // Spread ants in formation
		ant.y = Math.random() * 150 - 75;
		ant.scaleX = 0.7;
		ant.scaleY = 0.7;
		ant.alpha = 0.9;
		self.ants.push(ant);
	}
	self.speed = 2;
	self.isActive = false;
	self.duration = 0;
	self.maxDuration = 1800; // 30 seconds at 60fps - stay until crossing screen
	self.activate = function (yPosition) {
		self.y = yPosition;
		self.x = -200; // Start off-screen left
		self.isActive = true;
		self.duration = 0;
	};
	self.update = function () {
		if (self.isActive) {
			// Move ant swarm from left to right
			self.x += self.speed;
			self.duration++;
			// Keep ants in formation without circular movement
			for (var i = 0; i < self.ants.length; i++) {
				var ant = self.ants[i];
				// No circular movement - ants maintain their formation positions
			}
			// Deactivate when completely off-screen right
			if (self.x > 2248) {
				// 2048 + 200 buffer
				self.isActive = false;
				self.x = -200;
			}
		}
	};
	return self;
});
var Bug = Container.expand(function (bugType) {
	var self = Container.call(this);
	var type = bugType || 'fly';
	var bugGraphics = self.attachAsset(type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.bugType = type;
	self.speed = type === 'fly' ? 4 : type === 'butterfly' ? 3 : 2;
	self.velocityX = (Math.random() - 0.5) * self.speed;
	self.velocityY = (Math.random() - 0.5) * self.speed;
	self.changeDirectionTimer = 0;
	self.isCaught = false;
	self.update = function () {
		if (!self.isCaught) {
			// Move bug randomly
			self.x += self.velocityX;
			self.y += self.velocityY;
			self.changeDirectionTimer++;
			// Change direction randomly
			if (self.changeDirectionTimer > 20 + Math.random() * 30) {
				self.velocityX = (Math.random() - 0.5) * self.speed;
				self.velocityY = (Math.random() - 0.5) * self.speed;
				self.changeDirectionTimer = 0;
			}
			// Keep bugs within bounds
			if (self.x <= 50 || self.x >= 2048 - 50) {
				self.velocityX = -self.velocityX;
			}
			if (self.y <= 50 || self.y >= 2732 - 50) {
				self.velocityY = -self.velocityY;
			}
			// Prevent bugs from entering safe zone (bottom left corner - 400x400 area)
			if (self.x <= 400 && self.y >= 2332) {
				// Bug is trying to enter safe zone - bounce it away
				if (self.x <= 400) {
					self.velocityX = Math.abs(self.velocityX); // Force rightward movement
					self.x = 401; // Push bug out of safe zone immediately
				}
				if (self.y >= 2332) {
					self.velocityY = -Math.abs(self.velocityY); // Force upward movement
					self.y = 2331; // Push bug out of safe zone immediately
				}
			}
			// Add floating animation
			bugGraphics.y = Math.sin(LK.ticks * 0.1) * 3;
		}
	};
	return self;
});
var RoomObstacle = Container.expand(function (type) {
	var self = Container.call(this);
	var assetId = type || 'table_leg';
	var objectGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.obstacleType = type;
	return self;
});
var Spider = Container.expand(function () {
	var self = Container.call(this);
	var spiderGraphics = self.attachAsset('spider', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 6;
	self.velocityX = 0;
	self.velocityY = 0;
	self.targetX = 0;
	self.targetY = 0;
	self.isMoving = false;
	self.webNodes = [];
	self.moveToTarget = function (targetX, targetY) {
		self.targetX = targetX;
		self.targetY = targetY;
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 5) {
			self.velocityX = dx / distance * self.speed;
			self.velocityY = dy / distance * self.speed;
			self.isMoving = true;
			// Rotate spider to face movement direction
			var angle = Math.atan2(dy, dx);
			tween(spiderGraphics, {
				rotation: angle
			}, {
				duration: 100
			});
		}
	};
	self.createWebNode = function () {
		if (currentWebs >= maxWebs) {
			// Cannot create more webs
			return;
		}
		// Check if a web node already exists at this position
		for (var i = 0; i < self.webNodes.length; i++) {
			var existingNode = self.webNodes[i];
			var dx = existingNode.x - self.x;
			var dy = existingNode.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < 30) {
				// Web node already exists too close to this position
				return;
			}
		}
		// Remove oldest web node if we've reached the limit
		if (self.webNodes.length >= maxWebNodes) {
			var oldestNode = self.webNodes.shift(); // Remove first (oldest) element
			if (oldestNode && oldestNode.parent) {
				oldestNode.destroy();
			}
		}
		var webNode = LK.getAsset('web_node', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		webNode.x = self.x;
		webNode.y = self.y;
		self.webNodes.push(webNode);
		game.addChild(webNode);
		currentWebs++;
		webCountTxt.setText('Webs: ' + (maxWebs - currentWebs) + '/' + maxWebs);
		// Play web creation sound
		if (LK.getSound('web_create')) {
			LK.getSound('web_create').play();
		}
	};
	self.update = function () {
		if (self.isMoving) {
			// Move spider 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.isMoving = false;
				self.velocityX = 0;
				self.velocityY = 0;
			} else {
				self.x += self.velocityX;
				self.y += self.velocityY;
			}
			// Keep spider within bounds
			if (self.x <= 60) {
				self.x = 60;
				self.isMoving = false;
			}
			if (self.x >= 2048 - 60) {
				self.x = 2048 - 60;
				self.isMoving = false;
			}
			if (self.y <= 60) {
				self.y = 60;
				self.isMoving = false;
			}
			if (self.y >= 2732 - 60) {
				self.y = 2732 - 60;
				self.isMoving = false;
			}
		}
	};
	return self;
});
var WebTriangle = Container.expand(function (node1, node2, node3) {
	var self = Container.call(this);
	self.nodes = [node1, node2, node3];
	self.isComplete = false;
	self.checkIfComplete = function () {
		if (self.nodes.length === 3) {
			self.isComplete = true;
			return true;
		}
		return false;
	};
	self.containsBug = function (bug) {
		if (!self.isComplete) return false;
		// Simple point-in-triangle check using barycentric coordinates
		var x1 = self.nodes[0].x,
			y1 = self.nodes[0].y;
		var x2 = self.nodes[1].x,
			y2 = self.nodes[1].y;
		var x3 = self.nodes[2].x,
			y3 = self.nodes[2].y;
		var px = bug.x,
			py = bug.y;
		var denom = (y2 - y3) * (x1 - x3) + (x3 - x2) * (y1 - y3);
		var a = ((y2 - y3) * (px - x3) + (x3 - x2) * (py - y3)) / denom;
		var b = ((y3 - y1) * (px - x3) + (x1 - x3) * (py - y3)) / denom;
		var c = 1 - a - b;
		return a >= 0 && b >= 0 && c >= 0;
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x2c1810 // Dark brown for indoor environment
});

/**** 
* Game Code
****/ 
// Set garden environment background color
game.setBackgroundColor(0x654321);
// Create garden ground as single asset
var gardenGround = LK.getAsset('garden_ground', {
	anchorX: 0,
	anchorY: 0
});
gardenGround.x = 0;
gardenGround.y = 0;
gardenGround.alpha = 0.8;
game.addChild(gardenGround);
// Game variables
var spider;
var obstacles = [];
var bugs = [];
var webTriangles = [];
var score = 0;
var gameStarted = false;
var doubleClickTimer = 0;
var lastClickTime = 0;
var maxWebs = 30;
var currentWebs = 0;
var maxWebNodes = 30; // Maximum number of web nodes to keep on screen
// Level system variables
var currentLevel = 1;
var levelTargets = {
	1: {
		type: 'butterfly',
		count: 3,
		required: 3
	},
	2: {
		type: 'fly',
		count: 5,
		required: 5
	},
	3: {
		type: 'beetle',
		count: 4,
		required: 4
	},
	4: {
		type: 'butterfly',
		count: 6,
		required: 6
	},
	5: {
		type: 'fly',
		count: 8,
		required: 8
	}
};
var levelProgress = {
	butterfly: 0,
	fly: 0,
	beetle: 0
};
// Safe zone and timer variables
var safeZone = {
	x: 0,
	y: 2332,
	width: 400,
	height: 400
};
var timeOutsideSafeZone = 0;
var maxTimeOutside = 1800; // 30 seconds at 60fps
var isInSafeZone = false;
var lastIsInSafeZone = false;
var warningStarted = false;
// Ant swarm system variables
var antSwarms = [];
var antSwarmTimer = 0;
var antSwarmInterval = 1200; // 20 seconds at 60fps
var nextAntSwarmTime = antSwarmInterval;
// Create safe zone visual as a single asset
var safeZoneVisual = LK.getAsset('safe_zone', {
	anchorX: 0,
	anchorY: 0
});
safeZoneVisual.x = safeZone.x;
safeZoneVisual.y = safeZone.y;
safeZoneVisual.tint = 0xffffff;
safeZoneVisual.alpha = 0.6;
safeZoneVisual.scaleX = 2;
safeZoneVisual.scaleY = 2;
game.addChild(safeZoneVisual);
// Create ant swarms
for (var i = 0; i < 3; i++) {
	var antSwarm = new AntSwarm();
	antSwarms.push(antSwarm);
	game.addChild(antSwarm);
}
// Create spider at center of room in safe zone
spider = game.addChild(new Spider());
spider.x = 100; // Start in safe zone
spider.y = 2632; // Start in safe zone
// Create instruction text
var instructionTxt = new Text2('Tap to move spider continuously, double-tap to shoot web while moving!', {
	size: 60,
	fill: 0xffffff
});
instructionTxt.anchor.set(0.5, 0.5);
instructionTxt.x = 1024;
instructionTxt.y = 200;
game.addChild(instructionTxt);
// Score display
var scoreTxt = new Text2('Score: 0', {
	size: 80,
	fill: 0xffffff
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Web count display
var webCountTxt = new Text2('Webs: 30/30', {
	size: 60,
	fill: 0xffffff
});
webCountTxt.anchor.set(0.5, 0);
webCountTxt.y = 100;
LK.gui.top.addChild(webCountTxt);
// Level display
var levelTxt = new Text2('Level 1: Catch 3 butterflies', {
	size: 50,
	fill: 0xffffff
});
levelTxt.anchor.set(0.5, 0);
levelTxt.y = 170;
LK.gui.top.addChild(levelTxt);
// Timer display
var timerTxt = new Text2('Safe Zone Timer: 30s', {
	size: 40,
	fill: 0x00ff00
});
timerTxt.anchor.set(1, 0);
LK.gui.topRight.addChild(timerTxt);
// Function to create room obstacles
function createRoomObstacles() {
	// Clear existing items
	for (var k = 0; k < obstacles.length; k++) {
		if (obstacles[k] && obstacles[k].destroy) {
			obstacles[k].destroy();
		}
	}
	obstacles = [];
	// Table legs in various positions
	var obstaclePositions = [{
		x: 300,
		y: 400,
		type: 'table_leg'
	}, {
		x: 1700,
		y: 500,
		type: 'table_leg'
	}, {
		x: 800,
		y: 1200,
		type: 'table_leg'
	}, {
		x: 1400,
		y: 1800,
		type: 'table_leg'
	}, {
		x: 200,
		y: 2200,
		type: 'wall_corner'
	}, {
		x: 1800,
		y: 2400,
		type: 'wall_corner'
	}, {
		x: 1024,
		y: 800,
		type: 'table_leg'
	}, {
		x: 600,
		y: 2000,
		type: 'wall_corner'
	}];
	for (var i = 0; i < obstaclePositions.length; i++) {
		var obstacle = new RoomObstacle(obstaclePositions[i].type);
		obstacle.x = obstaclePositions[i].x;
		obstacle.y = obstaclePositions[i].y;
		obstacles.push(obstacle);
		game.addChild(obstacle);
	}
}
// Create room obstacles
createRoomObstacles();
// Function to spawn bugs
function spawnBug() {
	var bugTypes = ['fly', 'butterfly', 'beetle'];
	var randomType = bugTypes[Math.floor(Math.random() * bugTypes.length)];
	var bug = new Bug(randomType);
	// Spawn at random edge of screen
	var edge = Math.floor(Math.random() * 4);
	switch (edge) {
		case 0:
			// top
			bug.x = Math.random() * 2048;
			bug.y = 50;
			break;
		case 1:
			// right
			bug.x = 1998;
			bug.y = Math.random() * 2732;
			break;
		case 2:
			// bottom 
			// Avoid spawning in safe zone area (bottom left)
			do {
				bug.x = Math.random() * 2048;
			} while (bug.x <= 400); // Keep away from safe zone width
			bug.y = 2682;
			break;
		case 3:
			// left 
			bug.x = 50;
			// Avoid spawning in safe zone area (bottom left)
			do {
				bug.y = Math.random() * 2732;
			} while (bug.y >= 2332); // Keep away from safe zone height
			break;
	}
	bugs.push(bug);
	game.addChild(bug);
}
// Spawn initial bugs
for (var i = 0; i < 5; i++) {
	spawnBug();
}
// Touch input - move spider or create web
game.down = function (x, y, obj) {
	var currentTime = LK.ticks;
	var timeDiff = currentTime - lastClickTime;
	if (timeDiff < 30) {
		// Double click detected (within 0.5 seconds at 60fps)
		// Create web node at double-click location and continue moving there
		spider.createWebNode();
		spider.moveToTarget(x, y);
		if (LK.getSound('spider_move')) {
			LK.getSound('spider_move').play();
		}
	} else {
		// Single click - move spider to tap location
		spider.moveToTarget(x, y);
		if (LK.getSound('spider_move')) {
			LK.getSound('spider_move').play();
		}
	}
	lastClickTime = currentTime;
	// Hide instruction text after first tap
	if (instructionTxt && instructionTxt.parent) {
		tween(instructionTxt, {
			alpha: 0
		}, {
			duration: 1000,
			onFinish: function onFinish() {
				instructionTxt.destroy();
			}
		});
	}
	gameStarted = true;
};
// Game update loop
game.update = function () {
	// Check if spider is in safe zone
	isInSafeZone = spider.x >= safeZone.x && spider.x <= safeZone.x + safeZone.width && spider.y >= safeZone.y && spider.y <= safeZone.y + safeZone.height;
	// Handle safe zone timer - only start counting when leaving safe zone
	if (lastIsInSafeZone && !isInSafeZone) {
		// Just left safe zone - start countdown
		timeOutsideSafeZone = 0;
		timerTxt.alpha = 1; // Make timer visible
	}
	if (!isInSafeZone) {
		timeOutsideSafeZone++;
		var timeLeft = maxTimeOutside - timeOutsideSafeZone;
		var secondsLeft = Math.ceil(timeLeft / 60);
		if (timeLeft <= 0) {
			// Time's up - game over
			LK.showGameOver();
			return;
		}
		// Update timer display
		if (secondsLeft <= 10 && !warningStarted) {
			warningStarted = true;
			timerTxt.fill = 0xff0000;
			// Play warning sound every second for last 10 seconds
			if (LK.getSound('collision')) {
				LK.getSound('collision').play();
			}
		}
		if (secondsLeft <= 10 && LK.ticks % 60 === 0 && LK.getSound('collision')) {
			LK.getSound('collision').play();
		}
		// Blinking effect when outside safe zone - more intense blinking for last 10 seconds
		if (secondsLeft <= 10) {
			if (LK.ticks % 20 < 10) {
				timerTxt.alpha = 1;
			} else {
				timerTxt.alpha = 0.3;
			}
		} else if (LK.ticks % 30 < 15) {
			timerTxt.alpha = 1;
		} else {
			timerTxt.alpha = 0.3;
		}
		timerTxt.setText('Safe Zone Timer: ' + secondsLeft + 's');
		timerTxt.fill = secondsLeft <= 5 ? 0xff0000 : secondsLeft <= 10 ? 0xffff00 : 0x00ff00;
	} else {
		// Reset timer when in safe zone
		timeOutsideSafeZone = 0;
		warningStarted = false;
		timerTxt.setText('');
		timerTxt.alpha = 0; // Hide timer when in safe zone
	}
	// Update last safe zone state
	lastIsInSafeZone = isInSafeZone;
	// Handle ant swarm system
	antSwarmTimer++;
	if (antSwarmTimer >= nextAntSwarmTime) {
		// Spawn a new ant swarm
		for (var d = 0; d < antSwarms.length; d++) {
			var antSwarm = antSwarms[d];
			if (!antSwarm.isActive) {
				// Random Y position between 200 and 2300, but avoid safe zone area
				var randomY;
				do {
					randomY = 200 + Math.random() * 2100;
				} while (randomY >= safeZone.y - 100 && randomY <= safeZone.y + safeZone.height + 100);
				antSwarm.activate(randomY);
				break;
			}
		}
		// Reset timer with some randomness (18-22 seconds)
		antSwarmTimer = 0;
		nextAntSwarmTime = 1080 + Math.random() * 240;
	}
	// Check spider collision with active ant swarms
	for (var d = 0; d < antSwarms.length; d++) {
		var antSwarm = antSwarms[d];
		if (antSwarm.isActive) {
			// Check if spider intersects with any ant in the swarm
			for (var a = 0; a < antSwarm.ants.length; a++) {
				var ant = antSwarm.ants[a];
				var antWorldX = antSwarm.x + ant.x;
				var antWorldY = antSwarm.y + ant.y;
				var dx = spider.x - antWorldX;
				var dy = spider.y - antWorldY;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < 50) {
					// Spider hit poisonous ant - game over
					LK.showGameOver();
					return;
				}
			}
		}
	}
	// Spawn new bugs occasionally
	if (LK.ticks % 180 === 0 && bugs.length < 8) {
		// Every 3 seconds
		spawnBug();
	}
	// Check web triangles for caught bugs
	for (var t = 0; t < webTriangles.length; t++) {
		var triangle = webTriangles[t];
		if (triangle.isComplete) {
			for (var b = 0; b < bugs.length; b++) {
				var bug = bugs[b];
				if (!bug.isCaught && triangle.containsBug(bug)) {
					// Bug caught!
					bug.isCaught = true;
					score += bug.bugType === 'fly' ? 10 : bug.bugType === 'butterfly' ? 20 : 30;
					// Track level progress
					levelProgress[bug.bugType]++;
					var currentTarget = levelTargets[currentLevel];
					if (currentTarget && levelProgress[currentTarget.type] >= currentTarget.required) {
						// Level completed!
						currentLevel++;
						if (levelTargets[currentLevel]) {
							levelTxt.setText('Level ' + currentLevel + ': Catch ' + levelTargets[currentLevel].required + ' ' + levelTargets[currentLevel].type + 's');
						} else {
							// All levels completed
							LK.showYouWin();
							return;
						}
					} else if (currentTarget) {
						levelTxt.setText('Level ' + currentLevel + ': Catch ' + (currentTarget.required - levelProgress[currentTarget.type]) + ' more ' + currentTarget.type + 's');
					}
					// Give +10 web credits for catching bug
					if (currentWebs > 0) {
						currentWebs = Math.max(0, currentWebs - 10);
						webCountTxt.setText('Webs: ' + (maxWebs - currentWebs) + '/' + maxWebs);
					}
					scoreTxt.setText('Score: ' + score);
					LK.setScore(score);
					if (LK.getSound('bug_catch')) {
						LK.getSound('bug_catch').play();
					}
					// Remove bug after short delay
					tween(bug, {
						alpha: 0,
						scaleX: 0,
						scaleY: 0
					}, {
						duration: 500,
						onFinish: function onFinish() {
							if (bug.parent) {
								bug.destroy();
								// Spawn a new bug to replace the caught one
								spawnBug();
							}
						}
					});
				}
			}
		}
	}
	// Check web nodes for bug collision (kill bugs that touch web nodes)
	for (var n = 0; n < spider.webNodes.length; n++) {
		var webNode = spider.webNodes[n];
		for (var b = 0; b < bugs.length; b++) {
			var bug = bugs[b];
			if (!bug.isCaught) {
				var dx = bug.x - webNode.x;
				var dy = bug.y - webNode.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < 50) {
					// Collision distance
					// Bug touched web node - kill it
					bug.isCaught = true;
					score += bug.bugType === 'fly' ? 5 : bug.bugType === 'butterfly' ? 10 : 15;
					// Track level progress
					levelProgress[bug.bugType]++;
					var currentTarget = levelTargets[currentLevel];
					if (currentTarget && levelProgress[currentTarget.type] >= currentTarget.required) {
						// Level completed!
						currentLevel++;
						if (levelTargets[currentLevel]) {
							levelTxt.setText('Level ' + currentLevel + ': Catch ' + levelTargets[currentLevel].required + ' ' + levelTargets[currentLevel].type + 's');
						} else {
							// All levels completed
							LK.showYouWin();
							return;
						}
					} else if (currentTarget) {
						levelTxt.setText('Level ' + currentLevel + ': Catch ' + (currentTarget.required - levelProgress[currentTarget.type]) + ' more ' + currentTarget.type + 's');
					}
					// Give +10 web credits for catching bug
					if (currentWebs > 0) {
						currentWebs = Math.max(0, currentWebs - 10);
						webCountTxt.setText('Webs: ' + (maxWebs - currentWebs) + '/' + maxWebs);
					}
					scoreTxt.setText('Score: ' + score);
					LK.setScore(score);
					if (LK.getSound('bug_catch')) {
						LK.getSound('bug_catch').play();
					}
					// Remove bug immediately
					tween(bug, {
						alpha: 0,
						scaleX: 0,
						scaleY: 0
					}, {
						duration: 300,
						onFinish: function onFinish() {
							if (bug.parent) {
								bug.destroy();
								// Spawn a new bug to replace the killed one
								spawnBug();
							}
						}
					});
					break; // Exit web node loop for this bug
				}
			}
		}
	}
	// Create web triangles from spider's web nodes
	if (spider.webNodes.length >= 3) {
		// Check if we can form triangles from the last 3 nodes
		var nodeCount = spider.webNodes.length;
		if (nodeCount % 3 === 0) {
			var lastThreeNodes = spider.webNodes.slice(-3);
			var newTriangle = new WebTriangle(lastThreeNodes[0], lastThreeNodes[1], lastThreeNodes[2]);
			if (newTriangle.checkIfComplete()) {
				webTriangles.push(newTriangle);
			}
		}
	}
	// Reset bugs that go off screen instead of removing them
	for (var b = bugs.length - 1; b >= 0; b--) {
		var bug = bugs[b];
		if (bug.x < -50 || bug.x > 2098 || bug.y < -50 || bug.y > 2782) {
			// Reset bug position to random edge
			var edge = Math.floor(Math.random() * 4);
			switch (edge) {
				case 0:
					// top
					bug.x = Math.random() * 2048;
					bug.y = 50;
					break;
				case 1:
					// right
					bug.x = 1998;
					bug.y = Math.random() * 2732;
					break;
				case 2:
					// bottom 
					// Avoid resetting in safe zone area (bottom left)
					do {
						bug.x = Math.random() * 2048;
					} while (bug.x <= 400); // Keep away from safe zone width
					bug.y = 2682;
					break;
				case 3:
					// left 
					bug.x = 50;
					// Avoid resetting in safe zone area (bottom left)
					do {
						bug.y = Math.random() * 2732;
					} while (bug.y >= 2332); // Keep away from safe zone height
					break;
			}
		}
	}
	// Check if spider touches any bug (game over condition)
	for (var b = 0; b < bugs.length; b++) {
		var bug = bugs[b];
		if (!bug.isCaught) {
			var dx = bug.x - spider.x;
			var dy = bug.y - spider.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < 70) {
				// Spider touched bug - game over
				LK.showGameOver();
				return;
			}
		}
	}
};
// Start ambient nature sounds
LK.playMusic('ambient_nature', {
	loop: true
});

===================================================================
--- original.js
+++ change.js
@@ -38,14 +38,12 @@
 		if (self.isActive) {
 			// Move ant swarm from left to right
 			self.x += self.speed;
 			self.duration++;
-			// Animate individual ants
+			// Keep ants in formation without circular movement
 			for (var i = 0; i < self.ants.length; i++) {
 				var ant = self.ants[i];
-				ant.x += Math.sin(LK.ticks * 0.1 + i * 0.3) * 0.5;
-				ant.y += Math.cos(LK.ticks * 0.15 + i * 0.4) * 0.3;
-				ant.rotation += 0.02;
+				// No circular movement - ants maintain their formation positions
 			}
 			// Deactivate when completely off-screen right
 			if (self.x > 2248) {
 				// 2048 + 200 buffer