/**** 
* 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('ant', {
			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;
		ant.rotation = 0; // Face right (default orientation)
		ant.lastX = ant.x;
		ant.lastY = ant.y;
		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) {
			// Store old position for collision checking
			var oldX = self.x;
			var oldY = self.y;
			// Move ant swarm from left to right
			self.x += self.speed;
			self.duration++;
			// Check collision with stones for the entire swarm
			var swarmHitStone = false;
			for (var s = 0; s < stones.length; s++) {
				var stone = stones[s];
				var swarmCenterX = self.x;
				var swarmCenterY = self.y;
				var dx = swarmCenterX - stone.x;
				var dy = swarmCenterY - stone.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < stone.radius + 150) {
					// Swarm collision radius
					swarmHitStone = true;
					// Move swarm around the stone
					if (swarmCenterY < stone.y) {
						// Go above the stone
						self.y -= 3;
					} else {
						// Go below the stone
						self.y += 3;
					}
					break;
				}
			}
			// 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) {
			// Store old position for collision checking
			var oldX = self.x;
			var oldY = self.y;
			// Move bug randomly
			self.x += self.velocityX;
			self.y += self.velocityY;
			// Check collision with stones
			for (var s = 0; s < stones.length; s++) {
				var stone = stones[s];
				var dx = self.x - stone.x;
				var dy = self.y - stone.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < stone.radius + 30) {
					// Bug collision radius
					// Collision detected - bounce off stone
					self.x = oldX;
					self.y = oldY;
					// Reverse velocity and add some randomness
					self.velocityX = -self.velocityX + (Math.random() - 0.5) * 2;
					self.velocityY = -self.velocityY + (Math.random() - 0.5) * 2;
					break;
				}
			}
			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 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) {
			// Store old position for collision checking
			var oldX = self.x;
			var oldY = self.y;
			// 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;
			}
			// Check collision with stones
			for (var s = 0; s < stones.length; s++) {
				var stone = stones[s];
				var dx = self.x - stone.x;
				var dy = self.y - stone.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < stone.radius + 60) {
					// Spider collision radius
					// Collision detected - revert to old position and stop movement
					self.x = oldX;
					self.y = oldY;
					self.isMoving = false;
					self.velocityX = 0;
					self.velocityY = 0;
					break;
				}
			}
			// 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 Stone = Container.expand(function () {
	var self = Container.call(this);
	// Random stone size between 80-150 pixels
	var stoneSize = 80 + Math.random() * 70;
	var stoneGraphics = LK.getAsset('stone_shape', {
		width: stoneSize,
		height: stoneSize,
		color: 0x606060,
		shape: 'ellipse',
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(stoneGraphics);
	// Different shades of gray for stones
	var grayShades = [0x404040, 0x505050, 0x606060, 0x707070, 0x808080, 0x909090, 0xa0a0a0, 0xb0b0b0];
	stoneGraphics.tint = grayShades[Math.floor(Math.random() * grayShades.length)];
	self.radius = stoneSize / 2;
	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 stones = [];
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 baseStoneCount = 2; // Start with 2 stones
var stonesPerLevel = 2; // Add 2 stones per level
var maxStones = 30; // Maximum 30 stones
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
};
// Level timer variables
var levelStartTime = 0;
var levelTimeLimit = 0;
var levelTimerStarted = false;
var timeSpentOutsideSafeZone = 0; // Track actual time spent outside safe zone for level timer
// 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);
// Level timer display
var levelTimerTxt = new Text2('Level Time: 90s', {
	size: 45,
	fill: 0x00ffff
});
levelTimerTxt.anchor.set(1, 1);
LK.gui.bottomRight.addChild(levelTimerTxt);
// Create random stone obstacles
function createStones() {
	// Clear existing stones
	for (var k = 0; k < stones.length; k++) {
		if (stones[k] && stones[k].destroy) {
			stones[k].destroy();
		}
	}
	stones = [];
	// Create stones based on current level (start with 2, increase each level, max 30)
	var stoneCount = Math.min(maxStones, baseStoneCount + (currentLevel - 1) * stonesPerLevel);
	for (var i = 0; i < stoneCount; i++) {
		var stone = new Stone();
		var validPosition = false;
		var attempts = 0;
		// Try to find a valid position that doesn't overlap with safe zone or other obstacles
		while (!validPosition && attempts < 50) {
			stone.x = 100 + Math.random() * 1848; // Keep stones away from edges
			stone.y = 100 + Math.random() * 2532;
			// Check if stone is not in safe zone (bottom left corner)
			if (stone.x > 500 || stone.y < 2232) {
				// Check distance from other stones and obstacles
				var tooClose = false;
				// Check distance from other stones
				for (var j = 0; j < stones.length; j++) {
					var dx = stone.x - stones[j].x;
					var dy = stone.y - stones[j].y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < stone.radius + stones[j].radius + 50) {
						tooClose = true;
						break;
					}
				}
				if (!tooClose) {
					validPosition = true;
				}
			}
			attempts++;
		}
		if (validPosition) {
			stones.push(stone);
			game.addChild(stone);
		}
	}
}
// Create stones
createStones();
// 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;
	// Initialize level timer
	if (!levelTimerStarted) {
		levelStartTime = LK.ticks;
		levelTimeLimit = levelTargets[currentLevel].required * 30 * 60; // 30 seconds per bug × 60 fps
		timeSpentOutsideSafeZone = 0; // Reset time counter
		levelTimerStarted = 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;
			}
			// Make safe zone blink when 10 seconds left
			if (LK.ticks % 30 < 15) {
				safeZoneVisual.alpha = 0.8;
			} else {
				safeZoneVisual.alpha = 0.2;
			}
		}
		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
		safeZoneVisual.alpha = 0.6; // Reset safe zone visual alpha
	}
	// Update last safe zone state
	lastIsInSafeZone = isInSafeZone;
	// Handle level timer - only decrease when outside safe zone
	if (levelTimerStarted && gameStarted) {
		if (!isInSafeZone) {
			timeSpentOutsideSafeZone++;
		}
		var levelTimeRemaining = levelTimeLimit - timeSpentOutsideSafeZone;
		var levelSecondsLeft = Math.ceil(levelTimeRemaining / 60);
		if (levelTimeRemaining <= 0) {
			// Level time's up - game over
			LK.showGameOver();
			return;
		}
		// Update level timer display
		if (isInSafeZone) {
			levelTimerTxt.setText('Level Time: ' + levelSecondsLeft + 's (PAUSED)');
			levelTimerTxt.fill = 0x00ff00; // Green when paused in safe zone
			levelTimerTxt.alpha = 1;
		} else {
			levelTimerTxt.setText('Level Time: ' + levelSecondsLeft + 's');
			if (levelSecondsLeft <= 10) {
				levelTimerTxt.fill = 0xff0000; // Red when 10 seconds left
				// Blinking effect for last 10 seconds
				if (LK.ticks % 30 < 15) {
					levelTimerTxt.alpha = 1;
				} else {
					levelTimerTxt.alpha = 0.3;
				}
			} else if (levelSecondsLeft <= 30) {
				levelTimerTxt.fill = 0xffff00; // Yellow when 30 seconds left
				levelTimerTxt.alpha = 1;
			} else {
				levelTimerTxt.fill = 0x00ffff; // Cyan for normal time
				levelTimerTxt.alpha = 1;
			}
		}
	}
	// 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;
				}
			}
		}
	}
	// Count bugs by type
	var bugCounts = {
		fly: 0,
		butterfly: 0,
		beetle: 0
	};
	for (var b = 0; b < bugs.length; b++) {
		var bug = bugs[b];
		if (!bug.isCaught) {
			bugCounts[bug.bugType]++;
		}
	}
	// Maintain minimum 2 bugs of each type
	var bugTypes = ['fly', 'butterfly', 'beetle'];
	for (var t = 0; t < bugTypes.length; t++) {
		var bugType = bugTypes[t];
		while (bugCounts[bugType] < 2) {
			var newBug = new Bug(bugType);
			// Spawn at random edge of screen
			var edge = Math.floor(Math.random() * 4);
			switch (edge) {
				case 0:
					// top
					newBug.x = Math.random() * 2048;
					newBug.y = 50;
					break;
				case 1:
					// right
					newBug.x = 1998;
					newBug.y = Math.random() * 2732;
					break;
				case 2:
					// bottom 
					// Avoid spawning in safe zone area (bottom left)
					do {
						newBug.x = Math.random() * 2048;
					} while (newBug.x <= 400); // Keep away from safe zone width
					newBug.y = 2682;
					break;
				case 3:
					// left 
					newBug.x = 50;
					// Avoid spawning in safe zone area (bottom left)
					do {
						newBug.y = Math.random() * 2732;
					} while (newBug.y >= 2332); // Keep away from safe zone height
					break;
			}
			bugs.push(newBug);
			game.addChild(newBug);
			bugCounts[bugType]++;
		}
	}
	// Spawn new bugs occasionally if total count is low
	if (LK.ticks % 180 === 0 && bugs.length < 12) {
		// Every 3 seconds, spawn up to 12 total bugs
		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!
						// Play level completion sound
						if (LK.getSound('level_complete')) {
							LK.getSound('level_complete').play();
						}
						currentLevel++;
						if (levelTargets[currentLevel]) {
							// Regenerate map for new level
							createStones();
							// Reset spider position to safe zone
							spider.x = 100;
							spider.y = 2632;
							spider.isMoving = false;
							spider.velocityX = 0;
							spider.velocityY = 0;
							// Clear all web nodes
							for (var w = 0; w < spider.webNodes.length; w++) {
								if (spider.webNodes[w] && spider.webNodes[w].destroy) {
									spider.webNodes[w].destroy();
								}
							}
							spider.webNodes = [];
							webTriangles = [];
							currentWebs = 0;
							webCountTxt.setText('Webs: ' + (maxWebs - currentWebs) + '/' + maxWebs);
							// Reset all bugs positions to new spawns
							for (var b = bugs.length - 1; b >= 0; b--) {
								var bug = bugs[b];
								if (bug && bug.destroy) {
									bug.destroy();
								}
							}
							bugs = [];
							// Spawn sufficient bugs for new level
							for (var i = 0; i < 10; i++) {
								spawnBug();
							}
							levelTxt.setText('Level ' + currentLevel + ': Catch ' + levelTargets[currentLevel].required + ' ' + levelTargets[currentLevel].type + 's');
							// Reset level timer for new level
							levelStartTime = LK.ticks;
							levelTimeLimit = levelTargets[currentLevel].required * 30 * 60; // 30 seconds per bug × 60 fps
							timeSpentOutsideSafeZone = 0; // Reset time counter for new level
						} 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 from array immediately
					bugs.splice(b, 1);
					// Remove bug after short delay
					tween(bug, {
						alpha: 0,
						scaleX: 0,
						scaleY: 0
					}, {
						duration: 500,
						onFinish: function onFinish() {
							if (bug.parent) {
								var caughtBugType = bug.bugType; // Store the bug type before destroying
								bug.destroy();
								// Spawn a new bug of the same type to replace the caught one
								var newBug = new Bug(caughtBugType);
								// Spawn at random edge of screen
								var edge = Math.floor(Math.random() * 4);
								switch (edge) {
									case 0:
										// top
										newBug.x = Math.random() * 2048;
										newBug.y = 50;
										break;
									case 1:
										// right
										newBug.x = 1998;
										newBug.y = Math.random() * 2732;
										break;
									case 2:
										// bottom 
										// Avoid spawning in safe zone area (bottom left)
										do {
											newBug.x = Math.random() * 2048;
										} while (newBug.x <= 400); // Keep away from safe zone width
										newBug.y = 2682;
										break;
									case 3:
										// left 
										newBug.x = 50;
										// Avoid spawning in safe zone area (bottom left)
										do {
											newBug.y = Math.random() * 2732;
										} while (newBug.y >= 2332); // Keep away from safe zone height
										break;
								}
								bugs.push(newBug);
								game.addChild(newBug);
							}
						}
					});
				}
			}
		}
	}
	// 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!
						// Play level completion sound
						if (LK.getSound('level_complete')) {
							LK.getSound('level_complete').play();
						}
						currentLevel++;
						if (levelTargets[currentLevel]) {
							// Regenerate map for new level
							createStones();
							// Reset spider position to safe zone
							spider.x = 100;
							spider.y = 2632;
							spider.isMoving = false;
							spider.velocityX = 0;
							spider.velocityY = 0;
							// Clear all web nodes
							for (var w = 0; w < spider.webNodes.length; w++) {
								if (spider.webNodes[w] && spider.webNodes[w].destroy) {
									spider.webNodes[w].destroy();
								}
							}
							spider.webNodes = [];
							webTriangles = [];
							currentWebs = 0;
							webCountTxt.setText('Webs: ' + (maxWebs - currentWebs) + '/' + maxWebs);
							// Reset all bugs positions to new spawns
							for (var b = bugs.length - 1; b >= 0; b--) {
								var bug = bugs[b];
								if (bug && bug.destroy) {
									bug.destroy();
								}
							}
							bugs = [];
							// Spawn sufficient bugs for new level
							for (var i = 0; i < 10; i++) {
								spawnBug();
							}
							levelTxt.setText('Level ' + currentLevel + ': Catch ' + levelTargets[currentLevel].required + ' ' + levelTargets[currentLevel].type + 's');
							// Reset level timer for new level
							levelStartTime = LK.ticks;
							levelTimeLimit = levelTargets[currentLevel].required * 30 * 60; // 30 seconds per bug × 60 fps
							timeSpentOutsideSafeZone = 0; // Reset time counter for new level
						} 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 from array immediately
					bugs.splice(b, 1);
					// Remove bug immediately
					tween(bug, {
						alpha: 0,
						scaleX: 0,
						scaleY: 0
					}, {
						duration: 300,
						onFinish: function onFinish() {
							if (bug.parent) {
								var killedBugType = bug.bugType; // Store the bug type before destroying
								bug.destroy();
								// Spawn a new bug of the same type to replace the killed one
								var newBug = new Bug(killedBugType);
								// Spawn at random edge of screen
								var edge = Math.floor(Math.random() * 4);
								switch (edge) {
									case 0:
										// top
										newBug.x = Math.random() * 2048;
										newBug.y = 50;
										break;
									case 1:
										// right
										newBug.x = 1998;
										newBug.y = Math.random() * 2732;
										break;
									case 2:
										// bottom 
										// Avoid spawning in safe zone area (bottom left)
										do {
											newBug.x = Math.random() * 2048;
										} while (newBug.x <= 400); // Keep away from safe zone width
										newBug.y = 2682;
										break;
									case 3:
										// left 
										newBug.x = 50;
										// Avoid spawning in safe zone area (bottom left)
										do {
											newBug.y = Math.random() * 2732;
										} while (newBug.y >= 2332); // Keep away from safe zone height
										break;
								}
								bugs.push(newBug);
								game.addChild(newBug);
							}
						}
					});
					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
@@ -152,18 +152,8 @@
 		}
 	};
 	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,
@@ -291,15 +281,17 @@
 var Stone = Container.expand(function () {
 	var self = Container.call(this);
 	// Random stone size between 80-150 pixels
 	var stoneSize = 80 + Math.random() * 70;
-	var stoneGraphics = self.attachAsset('wall_corner', {
+	var stoneGraphics = LK.getAsset('stone_shape', {
+		width: stoneSize,
+		height: stoneSize,
+		color: 0x606060,
+		shape: 'ellipse',
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
-	// Scale to random size
-	stoneGraphics.scaleX = stoneSize / 80;
-	stoneGraphics.scaleY = stoneSize / 80;
+	self.addChild(stoneGraphics);
 	// Different shades of gray for stones
 	var grayShades = [0x404040, 0x505050, 0x606060, 0x707070, 0x808080, 0x909090, 0xa0a0a0, 0xb0b0b0];
 	stoneGraphics.tint = grayShades[Math.floor(Math.random() * grayShades.length)];
 	self.radius = stoneSize / 2;
@@ -358,9 +350,8 @@
 gardenGround.alpha = 0.8;
 game.addChild(gardenGround);
 // Game variables
 var spider;
-var obstacles = [];
 var stones = [];
 var bugs = [];
 var webTriangles = [];
 var score = 0;
@@ -496,61 +487,8 @@
 	fill: 0x00ffff
 });
 levelTimerTxt.anchor.set(1, 1);
 LK.gui.bottomRight.addChild(levelTimerTxt);
-// 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();
 // Create random stone obstacles
 function createStones() {
 	// Clear existing stones
 	for (var k = 0; k < stones.length; k++) {
@@ -582,21 +520,9 @@
 						tooClose = true;
 						break;
 					}
 				}
-				// Check distance from obstacles
 				if (!tooClose) {
-					for (var k = 0; k < obstacles.length; k++) {
-						var dx = stone.x - obstacles[k].x;
-						var dy = stone.y - obstacles[k].y;
-						var distance = Math.sqrt(dx * dx + dy * dy);
-						if (distance < stone.radius + 100) {
-							tooClose = true;
-							break;
-						}
-					}
-				}
-				if (!tooClose) {
 					validPosition = true;
 				}
 			}
 			attempts++;
@@ -903,9 +829,8 @@
 						}
 						currentLevel++;
 						if (levelTargets[currentLevel]) {
 							// Regenerate map for new level
-							createRoomObstacles();
 							createStones();
 							// Reset spider position to safe zone
 							spider.x = 100;
 							spider.y = 2632;
@@ -1036,9 +961,8 @@
 						}
 						currentLevel++;
 						if (levelTargets[currentLevel]) {
 							// Regenerate map for new level
-							createRoomObstacles();
 							createStones();
 							// Reset spider position to safe zone
 							spider.x = 100;
 							spider.y = 2632;