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

/**** 
* Classes
****/ 
// Carnivore class
var Carnivore = Container.expand(function () {
	var self = Container.call(this);
	var carnAsset = self.attachAsset('carnivore', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.target = null;
	self.speed = 1.5 + Math.random() * 1.2;
	self.eaten = false;
	self._chaseTime = 0; // How long we've been chasing a herbivore
	self._tired = false; // Are we tired?
	self._tiredTimer = 0; // How long left to rest
	// --- State management for wandering/hungry ---
	self.state = "hungry"; // "wandering" or "hungry"
	self._eatCooldown = 0; // frames left in wandering after eating
	self.update = function () {
		if (self.eaten) return;
		// Handle tired state
		if (self._tired) {
			self._tiredTimer--;
			if (self._tiredTimer <= 0) {
				self._tired = false;
				self._chaseTime = 0;
			}
			// While tired, don't chase or wander, just stand still
			return;
		}
		// Handle eat cooldown (wandering after eating)
		if (self._eatCooldown > 0) {
			self._eatCooldown--;
			if (self._eatCooldown === 0) {
				self.state = "hungry";
			}
		}
		// State: wandering (ignore prey)
		if (self.state === "wandering") {
			self.target = null; // Don't chase
			// --- Random wandering when not chasing herbivores ---
			if (!self._wanderTimer || self._wanderTimer <= 0) {
				var angle = Math.random() * Math.PI * 2;
				self._wanderAngle = angle;
				self._wanderTimer = 60 + Math.floor(Math.random() * 60);
			}
			if (typeof self._wanderAngle === "number") {
				self.x += Math.cos(self._wanderAngle) * self.speed * 0.5;
				self.y += Math.sin(self._wanderAngle) * self.speed * 0.5;
				self._wanderTimer--;
				// Keep inside map bounds (strictly)
				var minX = 124 + 60;
				var maxX = 124 + 1800 - 60;
				var minY = paletteY + 320 + 60;
				var maxY = paletteY + 320 + 2000 - 60;
				if (self.x < minX) self.x = minX;
				if (self.x > maxX) self.x = maxX;
				if (self.y < minY) self.y = minY;
				if (self.y > maxY) self.y = maxY;
			}
			self._chaseTime = 0; // Not chasing, reset chase timer
			return;
		}
		// State: hungry (look for prey)
		if (self.state === "hungry") {
			// Find nearest herbivore or pollinator if not already targeting
			if (!self.target || self.target.eaten) {
				var minDist = 999999,
					closest = null;
				// Check herbivores
				for (var i = 0; i < herbivores.length; i++) {
					var h = herbivores[i];
					if (h.eaten) continue;
					var dx = h.x - self.x,
						dy = h.y - self.y;
					var dist = dx * dx + dy * dy;
					if (dist < minDist) {
						minDist = dist;
						closest = h;
					}
				}
				// (Carnivores ignore pollinators)
				self.target = closest;
			}
			// --- Random wandering when not chasing herbivores ---
			if ((!self.target || self.target.eaten) && (!self._wanderTimer || self._wanderTimer <= 0)) {
				var angle = Math.random() * Math.PI * 2;
				self._wanderAngle = angle;
				self._wanderTimer = 60 + Math.floor(Math.random() * 60);
			}
			if (!self.target || self.target.eaten) {
				if (typeof self._wanderAngle === "number") {
					self.x += Math.cos(self._wanderAngle) * self.speed * 0.5;
					self.y += Math.sin(self._wanderAngle) * self.speed * 0.5;
					self._wanderTimer--;
					var minX = 124 + 60;
					var maxX = 124 + 1800 - 60;
					var minY = paletteY + 320 + 60;
					var maxY = paletteY + 320 + 2000 - 60;
					if (self.x < minX) self.x = minX;
					if (self.x > maxX) self.x = maxX;
					if (self.y < minY) self.y = minY;
					if (self.y > maxY) self.y = maxY;
				}
				self._chaseTime = 0; // Not chasing, reset chase timer
			}
			// Move toward target herbivore
			if (self.target && !self.target.eaten) {
				var dx = self.target.x - self.x;
				var dy = self.target.y - self.y;
				var dist = Math.sqrt(dx * dx + dy * dy);
				if (dist > 1) {
					self.x += dx / dist * self.speed;
					self.y += dy / dist * self.speed;
				}
				// Track how long we've been chasing
				self._chaseTime++;
				// If we've been chasing for more than 6 seconds (360 frames), get tired
				if (self._chaseTime > 360) {
					self._tired = true;
					self._tiredTimer = 600; // 10 seconds at 60fps
					self._chaseTime = 0;
					return;
				}
				// Eat herbivore or pollinator if close enough
				if (dist < 60 && !self.target.eaten) {
					// Remove from correct array if pollinator
					if (pollinators.indexOf(self.target) !== -1) {
						self.target.die();
						// Remove from pollinators array in main update loop, not here
					} else {
						self.target.die();
					}
					self.target = null;
					self._chaseTime = 0; // Reset chase timer after eating
					// Animate carnivore "eating"
					tween(self, {
						scaleX: 1.2,
						scaleY: 1.2
					}, {
						duration: 120,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							tween(self, {
								scaleX: 1,
								scaleY: 1
							}, {
								duration: 120,
								easing: tween.easeIn
							});
						}
					});
					// After eating, enter wandering state for 1 minute (3600 frames)
					self.state = "wandering";
					self._eatCooldown = 3600;
				}
			}
		} // end hungry state
	};
	// Carnivores are not eaten in this MVP
	return self;
});
// Egg class
var Egg = Container.expand(function () {
	var self = Container.call(this);
	// Use a custom egg shape asset
	var eggAsset = self.attachAsset('egg', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1,
		scaleY: 1
	});
	self.hatched = false;
	self._hatchTimer = 420 + Math.floor(Math.random() * 180); // 7-10 seconds
	self.update = function () {
		if (self.hatched) return;
		self._hatchTimer--;
		if (self._hatchTimer <= 0) {
			self.hatched = true;
			// Animate egg hatching
			tween(self, {
				scaleX: 1.2,
				scaleY: 1.2,
				alpha: 0.5
			}, {
				duration: 200,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Spawn a new herbivore at this position
					var herb = new Herbivore();
					herb.x = self.x;
					herb.y = self.y;
					herb.scaleX = 1;
					herb.scaleY = 1;
					herb.alpha = 1;
					if (self.parent) self.parent.addChild(herb);
					herbivores.push(herb);
					self.destroy();
				}
			});
		}
	};
	return self;
});
// Herbivore class
var Herbivore = Container.expand(function () {
	var self = Container.call(this);
	var herbAsset = self.attachAsset('herbivore', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.target = null;
	self.speed = 1.2 + Math.random() * 1.0;
	self.eaten = false;
	// Track number of plants eaten for egg laying
	self._plantsEaten = 0;
	// --- State management for hungry/sleepy ---
	self.state = "hungry"; // "hungry" or "sleepy"
	self._sleepTimer = 0; // frames left in sleepy state
	self.update = function () {
		if (self.eaten) return;
		// Handle sleepy state
		if (self.state === "sleepy") {
			// Check for nearby carnivore and possibly wake up
			var nearestCarn = null;
			var minCarnDist = 999999;
			for (var ci = 0; ci < carnivores.length; ci++) {
				var carn = carnivores[ci];
				if (carn.eaten) continue;
				var cdx = carn.x - self.x;
				var cdy = carn.y - self.y;
				var cdist = cdx * cdx + cdy * cdy;
				if (cdist < minCarnDist) {
					minCarnDist = cdist;
					nearestCarn = carn;
				}
			}
			// If carnivore is within 300px, 50% chance to wake up and run away
			if (nearestCarn && Math.sqrt(minCarnDist) < 300) {
				// Only try to wake up once per frame if still sleepy
				if (!self._triedWakeThisFrame) {
					self._triedWakeThisFrame = true;
					if (Math.random() < 0.5) {
						// Wake up and run away from carnivore
						self.state = "hungry";
						// Move away from carnivore immediately
						var dx = self.x - nearestCarn.x;
						var dy = self.y - nearestCarn.y;
						var dist = Math.sqrt(dx * dx + dy * dy);
						if (dist > 1) {
							// Move a burst away (3x speed for one frame)
							self.x += dx / dist * (self.speed * 3);
							self.y += dy / dist * (self.speed * 3);
						}
						// Clamp to map area
						var minX = 124 + 60;
						var maxX = 124 + 1800 - 60;
						var minY = paletteY + 320 + 60;
						var maxY = paletteY + 320 + 2000 - 60;
						if (self.x < minX) self.x = minX;
						if (self.x > maxX) self.x = maxX;
						if (self.y < minY) self.y = minY;
						if (self.y > maxY) self.y = maxY;
						// Don't continue sleeping
						return;
					}
				}
			} else {
				self._triedWakeThisFrame = false;
			}
			self._sleepTimer--;
			if (self._sleepTimer <= 0) {
				self.state = "wandering";
				self._wanderAfterSleepTimer = 600; // 10 seconds at 60fps
			}
			// While sleepy, don't move or seek food
			return;
		}
		// Wandering state after sleep: ignore plants, just wander for 10s, then become hungry
		if (self.state === "wandering") {
			if (typeof self._wanderAfterSleepTimer === "undefined") self._wanderAfterSleepTimer = 600;
			self._wanderAfterSleepTimer--;
			// --- Random wandering ---
			if (!self._wanderTimer || self._wanderTimer <= 0) {
				var angle = Math.random() * Math.PI * 2;
				self._wanderAngle = angle;
				self._wanderTimer = 60 + Math.floor(Math.random() * 60);
			}
			if (typeof self._wanderAngle === "number") {
				self.x += Math.cos(self._wanderAngle) * self.speed * 0.5;
				self.y += Math.sin(self._wanderAngle) * self.speed * 0.5;
				self._wanderTimer--;
				// Keep inside map bounds (strictly)
				var minX = 124 + 60;
				var maxX = 124 + 1800 - 60;
				var minY = paletteY + 320 + 60;
				var maxY = paletteY + 320 + 2000 - 60;
				if (self.x < minX) self.x = minX;
				if (self.x > maxX) self.x = maxX;
				if (self.y < minY) self.y = minY;
				if (self.y > maxY) self.y = maxY;
			}
			if (self._wanderAfterSleepTimer <= 0) {
				self.state = "hungry";
			}
			return;
		}
		// Only seek food if hungry
		if (self.state === "hungry") {
			// Find nearest plant if not already targeting
			if (!self.target || self.target.eaten) {
				var minDist = 999999,
					closest = null;
				for (var i = 0; i < plants.length; i++) {
					var p = plants[i];
					if (p.eaten) continue;
					var dx = p.x - self.x,
						dy = p.y - self.y;
					var dist = dx * dx + dy * dy;
					if (dist < minDist) {
						minDist = dist;
						closest = p;
					}
				}
				self.target = closest;
			}
			// Check for nearest carnivore
			var nearestCarn = null;
			var minCarnDist = 999999;
			for (var ci = 0; ci < carnivores.length; ci++) {
				var carn = carnivores[ci];
				if (carn.eaten) continue;
				var cdx = carn.x - self.x;
				var cdy = carn.y - self.y;
				var cdist = cdx * cdx + cdy * cdy;
				if (cdist < minCarnDist) {
					minCarnDist = cdist;
					nearestCarn = carn;
				}
			}
			var carnivoreTooClose = false;
			var carnDist = 0;
			var runAwayDX = 0,
				runAwayDY = 0;
			if (nearestCarn) {
				carnDist = Math.sqrt((nearestCarn.x - self.x) * (nearestCarn.x - self.x) + (nearestCarn.y - self.y) * (nearestCarn.y - self.y));
				if (carnDist < 300) {
					// If carnivore is within 300px, run away
					carnivoreTooClose = true;
					runAwayDX = self.x - nearestCarn.x;
					runAwayDY = self.y - nearestCarn.y;
				}
			}
			if (carnivoreTooClose && carnDist > 1) {
				// Run away from carnivore
				self.x += runAwayDX / carnDist * (self.speed * 1.5);
				self.y += runAwayDY / carnDist * (self.speed * 1.5);
			} else {
				// --- Random wandering when not chasing plant ---
				if ((!self.target || self.target.eaten) && (!self._wanderTimer || self._wanderTimer <= 0)) {
					// Pick a new random direction every 60-120 frames
					var angle = Math.random() * Math.PI * 2;
					self._wanderAngle = angle;
					self._wanderTimer = 60 + Math.floor(Math.random() * 60);
				}
				if (!self.target || self.target.eaten) {
					// Wander in the chosen direction
					if (typeof self._wanderAngle === "number") {
						self.x += Math.cos(self._wanderAngle) * self.speed * 0.5;
						self.y += Math.sin(self._wanderAngle) * self.speed * 0.5;
						self._wanderTimer--;
						// Keep inside map bounds (strictly)
						var minX = 124 + 60;
						var maxX = 124 + 1800 - 60;
						var minY = paletteY + 320 + 60;
						var maxY = paletteY + 320 + 2000 - 60;
						if (self.x < minX) self.x = minX;
						if (self.x > maxX) self.x = maxX;
						if (self.y < minY) self.y = minY;
						if (self.y > maxY) self.y = maxY;
					}
				}
				// Move toward target plant
				if (self.target && !self.target.eaten) {
					var dx = self.target.x - self.x;
					var dy = self.target.y - self.y;
					var dist = Math.sqrt(dx * dx + dy * dy);
					if (dist > 1) {
						self.x += dx / dist * self.speed;
						self.y += dy / dist * self.speed;
					}
					// Eat plant if close enough
					if (dist < 60 && !self.target.eaten) {
						var eatenPlant = self.target;
						self.target.die();
						self.target = null;
						// Animate herbivore "eating"
						tween(self, {
							scaleX: 1.2,
							scaleY: 1.2
						}, {
							duration: 120,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								tween(self, {
									scaleX: 1,
									scaleY: 1
								}, {
									duration: 120,
									easing: tween.easeIn
								});
							}
						});
						// After eating, enter sleepy state for 10 seconds (600 frames)
						self.state = "sleepy";
						self._sleepTimer = 600;
						// Increment plants eaten counter
						self._plantsEaten = (self._plantsEaten || 0) + 1;
						// Lay an egg if 4 plants have been eaten, then reset counter
						if (self._plantsEaten >= 4) {
							var egg = new Egg();
							egg.x = self.x;
							egg.y = self.y;
							egg.scaleX = 0.5;
							egg.scaleY = 0.5;
							egg.alpha = 1;
							if (self.parent) self.parent.addChild(egg);
							if (typeof eggs !== "undefined") eggs.push(egg);
							self._plantsEaten = 0;
						}
					}
				}
			}
		}
	};
	// Called when eaten by carnivore
	self.die = function (_onFinish) {
		if (self.eaten) return;
		self.eaten = true;
		tween(self, {
			scaleX: 0,
			scaleY: 0,
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				self.destroy();
				if (_onFinish) _onFinish();
			}
		});
	};
	return self;
});
// Plant class
var Plant = Container.expand(function () {
	var self = Container.call(this);
	var plantAsset = self.attachAsset('plant', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Plants are static, but we can animate them when eaten
	self.eaten = false;
	self.die = function (_onFinish2) {
		if (self.eaten) return;
		self.eaten = true;
		tween(self, {
			scaleX: 0,
			scaleY: 0,
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				self.destroy();
				if (_onFinish2) _onFinish2();
			}
		});
	};
	return self;
});
// Pollinator class
var Pollinator = Container.expand(function () {
	var self = Container.call(this);
	var pollAsset = self.attachAsset('pollinator', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.state = "seek"; // "seek", "scatter", "planting"
	self.target = null;
	self.speed = 2 + Math.random();
	self._scatterTimer = 0;
	self._scatterAngle = 0;
	self._plantSeedTimer = 0;
	self._hasSeed = true;
	self.eaten = false;
	self.lastWasTouchingPlant = false;
	self.update = function () {
		if (self.eaten) return;
		// SEEK: Find nearest plant and move to it, but run from carnivores if close
		if (self.state === "seek") {
			// Check for nearest carnivore
			var nearestCarn = null;
			var minCarnDist = 999999;
			for (var ci = 0; ci < carnivores.length; ci++) {
				var carn = carnivores[ci];
				if (carn.eaten) continue;
				var cdx = carn.x - self.x;
				var cdy = carn.y - self.y;
				var cdist = cdx * cdx + cdy * cdy;
				if (cdist < minCarnDist) {
					minCarnDist = cdist;
					nearestCarn = carn;
				}
			}
			var carnivoreTooClose = false;
			var carnDist = 0;
			var runAwayDX = 0,
				runAwayDY = 0;
			if (nearestCarn) {
				carnDist = Math.sqrt((nearestCarn.x - self.x) * (nearestCarn.x - self.x) + (nearestCarn.y - self.y) * (nearestCarn.y - self.y));
				if (carnDist < 220) {
					// Run if carnivore is within 220px
					carnivoreTooClose = true;
					runAwayDX = self.x - nearestCarn.x;
					runAwayDY = self.y - nearestCarn.y;
				}
			}
			if (carnivoreTooClose && carnDist > 1) {
				// Run away from carnivore (burst speed)
				self.x += runAwayDX / carnDist * (self.speed * 2.2);
				self.y += runAwayDY / carnDist * (self.speed * 2.2);
			} else {
				// Find nearest plant
				if (!self.target || self.target.eaten) {
					var minDist = 999999,
						closest = null;
					for (var i = 0; i < plants.length; i++) {
						var p = plants[i];
						if (p.eaten) continue;
						var dx = p.x - self.x,
							dy = p.y - self.y;
						var dist = dx * dx + dy * dy;
						if (dist < minDist) {
							minDist = dist;
							closest = p;
						}
					}
					self.target = closest;
				}
				// Move toward target plant
				if (self.target && !self.target.eaten) {
					var dx = self.target.x - self.x;
					var dy = self.target.y - self.y;
					var dist = Math.sqrt(dx * dx + dy * dy);
					if (dist > 1) {
						self.x += dx / dist * self.speed;
						self.y += dy / dist * self.speed;
					}
					// Check for touching plant (within 60px)
					var isTouching = dist < 60;
					if (!self.lastWasTouchingPlant && isTouching) {
						// Just touched plant
						self.state = "scatter";
						self._scatterTimer = 60 + Math.floor(Math.random() * 60); // 1-2 seconds
						self._scatterAngle = Math.random() * Math.PI * 2;
					}
					self.lastWasTouchingPlant = isTouching;
				} else {
					// No plant to go to, wander randomly
					if (!self._wanderTimer || self._wanderTimer <= 0) {
						self._wanderAngle = Math.random() * Math.PI * 2;
						self._wanderTimer = 60 + Math.floor(Math.random() * 60);
					}
					if (typeof self._wanderAngle === "number") {
						self.x += Math.cos(self._wanderAngle) * self.speed * 0.5;
						self.y += Math.sin(self._wanderAngle) * self.speed * 0.5;
						self._wanderTimer--;
					}
				}
			}
		}
		// SCATTER: Move in a random direction for a short time
		else if (self.state === "scatter") {
			self.x += Math.cos(self._scatterAngle) * self.speed * 2;
			self.y += Math.sin(self._scatterAngle) * self.speed * 2;
			self._scatterTimer--;
			if (self._scatterTimer <= 0) {
				self.state = "planting";
				self._plantSeedTimer = 30 + Math.floor(Math.random() * 30); // short pause before planting
			}
		}
		// PLANTING: Pause, then plant a seed
		else if (self.state === "planting") {
			self._plantSeedTimer--;
			if (self._plantSeedTimer <= 0 && self._hasSeed) {
				// Place a seed at current position
				var seed = new Seed();
				seed.x = self.x;
				seed.y = self.y;
				seed.scaleX = 0.4;
				seed.scaleY = 0.4;
				seed.alpha = 1;
				seeds.push(seed);
				if (self.parent) self.parent.addChild(seed);
				self._hasSeed = false;
				// After planting, look for another plant
				self.state = "seek";
				self.target = null;
				self._hasSeed = true;
			}
		}
		// Keep inside map bounds
		var minX = 124 + 60;
		var maxX = 124 + 1800 - 60;
		var minY = paletteY + 320 + 60;
		var maxY = paletteY + 320 + 2000 - 60;
		if (self.x < minX) self.x = minX;
		if (self.x > maxX) self.x = maxX;
		if (self.y < minY) self.y = minY;
		if (self.y > maxY) self.y = maxY;
	};
	self.die = function () {
		if (self.eaten) return;
		self.eaten = true;
		tween(self, {
			scaleX: 0,
			scaleY: 0,
			alpha: 0
		}, {
			duration: 200,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	return self;
});
// Seed class
var Seed = Container.expand(function () {
	var self = Container.call(this);
	// Use dedicated brown seed asset
	var seedAsset = self.attachAsset('seed', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.4,
		scaleY: 0.4
	});
	self.growing = false;
	self.eaten = false;
	self._growTimer = 600; // 10 seconds at 60fps
	self.update = function () {
		if (self.eaten) return;
		if (!self.growing) {
			self._growTimer--;
			if (self._growTimer <= 0) {
				self.growing = true;
				// Animate seed growing into plant
				tween(self, {
					scaleX: 1,
					scaleY: 1,
					alpha: 0.7
				}, {
					duration: 300,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						// Replace seed with a new plant at same position
						var newPlant = new Plant();
						newPlant.x = self.x;
						newPlant.y = self.y;
						newPlant.scaleX = 1;
						newPlant.scaleY = 1;
						newPlant.alpha = 1;
						plants.push(newPlant);
						if (self.parent) self.parent.addChild(newPlant);
						self.eaten = true;
						self.destroy();
					}
				});
			}
		}
	};
	// If something eats the seed (future-proof)
	self.die = function () {
		if (self.eaten) return;
		self.eaten = true;
		tween(self, {
			scaleX: 0,
			scaleY: 0,
			alpha: 0
		}, {
			duration: 200,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x228B22 //{7C} // Set to a strong green (forest green)
});

/**** 
* Game Code
****/ 
// --- Global arrays for organisms ---
// --- Asset Initialization ---
var plants = [];
var herbivores = [];
var carnivores = [];
var seeds = [];
var eggs = []; // Track all eggs globally
var pollinators = [];
// --- Palette UI ---
var paletteY = 180; // y position for palette
var paletteSpacing = 260;
var paletteItems = [];
// Shift the palette even further left so it is not offscreen
var paletteTotalWidth = paletteSpacing * 2;
var paletteXStart = 2048 / 2 - paletteTotalWidth / 2 - 1300;
// Create palette items for drag-and-drop
function createPaletteItem(type, x, y) {
	var assetId, color, label;
	if (type === 'plant') {
		assetId = 'plant';
		color = 0x6adf60;
		label = 'Plant';
	} else if (type === 'herbivore') {
		assetId = 'herbivore';
		color = 0xf7e26b;
		label = 'Herbivore';
	} else if (type === 'pollinator') {
		assetId = 'pollinator';
		color = 0xffc300;
		label = 'Pollinator';
	} else {
		assetId = 'carnivore';
		color = 0xe74c3c;
		label = 'Carnivore';
	}
	;
	// Update all eggs
	for (var i = eggs.length - 1; i >= 0; i--) {
		var e = eggs[i];
		if (!e.parent || e.hatched) {
			eggs.splice(i, 1);
			continue;
		}
		if (e.update) e.update();
	}
	;
	// Update all pollinators
	for (var i = pollinators.length - 1; i >= 0; i--) {
		var p = pollinators[i];
		if (p.eaten) {
			pollinators.splice(i, 1);
			continue;
		}
		if (p.update) p.update();
	}
	var node = new Container();
	var icon = node.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	node.x = x;
	node.y = y;
	node.type = type;
	// Add label
	var txt = new Text2(label, {
		size: 60,
		fill: "#fff"
	});
	txt.anchor.set(0.5, 0);
	txt.y = 60;
	node.addChild(txt);
	// Add to GUI overlay (so it stays on top)
	LK.gui.top.addChild(node);
	paletteItems.push(node);
	return node;
}
// Place palette items (avoid top left 100x100)
var plantPalette = createPaletteItem('plant', paletteXStart, paletteY);
var herbPalette = createPaletteItem('herbivore', paletteXStart + paletteSpacing, paletteY);
var carnPalette = createPaletteItem('carnivore', paletteXStart + paletteSpacing * 2, paletteY);
// Add pollinator palette item
var pollinatorPalette = createPaletteItem('pollinator', paletteXStart + paletteSpacing * 3, paletteY);
// --- Drag and Drop Logic ---
var dragging = null; // {type, node, paletteRef}
var dragOffsetX = 0,
	dragOffsetY = 0;
// Helper: create organism at x,y
function createOrganism(type, x, y) {
	var obj;
	if (type === 'plant') {
		obj = new Plant();
		plants.push(obj);
		// --- Random seed spawn after placing a plant ---
		// Only spawn seeds if there is at least one plant after placing
		if (plants.length > 0) {
			// 70% chance to spawn a seed
			if (Math.random() < 0.7) {
				// Pick a random position near the plant
				var angle = Math.random() * Math.PI * 2;
				var dist = 80 + Math.random() * 60;
				var sx = x + Math.cos(angle) * dist;
				var sy = y + Math.sin(angle) * dist;
				// Clamp to map area
				var minX = 124 + 60;
				var maxX = 124 + 1800 - 60;
				var minY = paletteY + 320 + 60;
				var maxY = paletteY + 320 + 2000 - 60;
				if (sx < minX) sx = minX;
				if (sx > maxX) sx = maxX;
				if (sy < minY) sy = minY;
				if (sy > maxY) sy = maxY;
				// Only spawn if there are still plants (none eaten)
				if (plants.length > 0) {
					var seed = new Seed();
					seed.x = sx;
					seed.y = sy;
					seed.scaleX = 0.4;
					seed.scaleY = 0.4;
					seed.alpha = 1;
					seeds.push(seed);
					game.addChild(seed);
				}
			}
		}
	} else if (type === 'herbivore') {
		obj = new Herbivore();
		herbivores.push(obj);
	} else if (type === 'pollinator') {
		obj = new Pollinator();
		pollinators.push(obj);
	} else {
		obj = new Carnivore();
		carnivores.push(obj);
	}
	obj.x = x;
	obj.y = y;
	obj.scaleX = 1;
	obj.scaleY = 1;
	obj.alpha = 1;
	game.addChild(obj);
	return obj;
}
// Helper: check if point is inside a palette item
function isInPalette(x, y, node) {
	var bounds = {
		x: node.x - 60,
		y: node.y - 60,
		w: 120,
		h: 120
	};
	return x >= bounds.x && x <= bounds.x + bounds.w && y >= bounds.y && y <= bounds.y + bounds.h;
}
// --- Event Handlers ---
// Down: start drag if on palette
game.down = function (x, y, obj) {
	// Check if touch/click is on a palette item
	for (var i = 0; i < paletteItems.length; i++) {
		var p = paletteItems[i];
		// Convert GUI coordinates to game coordinates
		var guiPos = LK.gui.top.toLocal({
			x: x,
			y: y
		}, game);
		if (isInPalette(guiPos.x, guiPos.y, p)) {
			// Start dragging a new organism
			dragging = {
				type: p.type,
				node: createOrganism(p.type, x, y),
				paletteRef: p
			};
			dragOffsetX = 0;
			dragOffsetY = 0;
			// Make it semi-transparent while dragging
			dragging.node.alpha = 0.7;
			return;
		}
	}
	// If not on palette, check if on an organism to move it
	// Check if touch/click is on an organism to move it
	var found = false;
	var allOrganisms = plants.concat(herbivores, carnivores, pollinators);
	for (var i = allOrganisms.length - 1; i >= 0; i--) {
		var org = allOrganisms[i];
		// Only allow moving if not eaten and touch is within 60px radius of center
		var dx = x - org.x;
		var dy = y - org.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (!org.eaten && dist < 60) {
			dragging = {
				type: plants.indexOf(org) !== -1 ? 'plant' : herbivores.indexOf(org) !== -1 ? 'herbivore' : 'carnivore',
				node: org,
				paletteRef: null
			};
			dragOffsetX = org.x - x;
			dragOffsetY = org.y - y;
			org.alpha = 0.7;
			found = true;
			break;
		}
	}
	if (!found) {
		dragging = null;
	}
};
// Move: update drag position
game.move = function (x, y, obj) {
	if (dragging && dragging.node) {
		var minX = 124 + 60;
		var maxX = 124 + 1800 - 60;
		var minY = paletteY + 320 + 60;
		var maxY = paletteY + 320 + 2000 - 60;
		var newX = x + dragOffsetX;
		var newY = y + dragOffsetY;
		// Clamp to map area
		if (newX < minX) newX = minX;
		if (newX > maxX) newX = maxX;
		if (newY < minY) newY = minY;
		if (newY > maxY) newY = maxY;
		dragging.node.x = newX;
		dragging.node.y = newY;
	}
};
// Up: drop organism if dragging
game.up = function (x, y, obj) {
	if (dragging && dragging.node) {
		// If dropped inside palette area, destroy (cancel)
		var guiPos = LK.gui.top.toLocal({
			x: x,
			y: y
		}, game);
		var cancel = false;
		for (var i = 0; i < paletteItems.length; i++) {
			if (isInPalette(guiPos.x, guiPos.y, paletteItems[i])) {
				cancel = true;
				break;
			}
		}
		if (cancel) {
			// Remove organism
			dragging.node.destroy();
			if (dragging.type === 'plant') plants.pop();else if (dragging.type === 'herbivore') herbivores.pop();else if (dragging.type === 'carnivore') carnivores.pop();else if (dragging.type === 'pollinator') pollinators.pop();
		} else {
			// Place organism: snap alpha to 1
			dragging.node.alpha = 1;
		}
		dragging = null;
	}
};
// --- Main Update Loop ---
game.update = function () {
	// Update all herbivores
	for (var i = herbivores.length - 1; i >= 0; i--) {
		var h = herbivores[i];
		if (h.eaten) {
			herbivores.splice(i, 1);
			continue;
		}
		if (h.update) h.update();
	}
	// Update all carnivores
	for (var i = carnivores.length - 1; i >= 0; i--) {
		var c = carnivores[i];
		if (c.eaten) {
			carnivores.splice(i, 1);
			continue;
		}
		if (c.update) c.update();
	}
	// Clean up dead plants
	for (var i = plants.length - 1; i >= 0; i--) {
		var p = plants[i];
		if (p.eaten) {
			plants.splice(i, 1);
		}
	}
	// Update all seeds
	for (var i = seeds.length - 1; i >= 0; i--) {
		var s = seeds[i];
		if (s.eaten) {
			seeds.splice(i, 1);
			continue;
		}
		if (s.update) s.update();
	}
};
// --- Instructions Text ---
var infoTxt = new Text2("Drag organisms from the palette to the map below.\nHerbivores eat plants. Carnivores eat herbivores.", {
	size: 60,
	fill: 0xFFFFFF
});
infoTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(infoTxt);
infoTxt.x = 2048 / 2;
infoTxt.y = paletteY + 160;
// --- Random seed spawning around the map if there are any plants ---
var randomSeedSpawnTimer = null;
function startRandomSeedSpawning() {
	if (randomSeedSpawnTimer !== null) return;
	randomSeedSpawnTimer = LK.setInterval(function () {
		// Only spawn if there are any plants
		if (plants.length > 0) {
			// 40% chance per interval to spawn a seed
			if (Math.random() < 0.4) {
				// Pick a random position inside the map area
				var minX = 124 + 60;
				var maxX = 124 + 1800 - 60;
				var minY = paletteY + 320 + 60;
				var maxY = paletteY + 320 + 2000 - 60;
				var sx = minX + Math.random() * (maxX - minX);
				var sy = minY + Math.random() * (maxY - minY);
				var seed = new Seed();
				seed.x = sx;
				seed.y = sy;
				seed.scaleX = 0.4;
				seed.scaleY = 0.4;
				seed.alpha = 1;
				seeds.push(seed);
				game.addChild(seed);
			}
		}
		// If no plants, stop spawning
		if (plants.length === 0 && randomSeedSpawnTimer !== null) {
			LK.clearInterval(randomSeedSpawnTimer);
			randomSeedSpawnTimer = null;
		}
	}, 120); // Try every 2 seconds
}
// Start random seed spawning at game start
startRandomSeedSpawning();
// --- Map Area Border (for visual feedback) ---
var mapBorder = LK.getAsset('plant', {
	anchorX: 0,
	anchorY: 0,
	width: 1800,
	height: 2000,
	color: 0x2e8b57
});
mapBorder.alpha = 0.12;
game.addChild(mapBorder);
mapBorder.x = 124;
mapBorder.y = paletteY + 320;
// --- End of Game Code ---

===================================================================
--- original.js
+++ change.js
@@ -168,16 +168,15 @@
 });
 // Egg class
 var Egg = Container.expand(function () {
 	var self = Container.call(this);
-	// Use the seed asset for egg, but tint it blue for visibility
-	var eggAsset = self.attachAsset('seed', {
+	// Use a custom egg shape asset
+	var eggAsset = self.attachAsset('egg', {
 		anchorX: 0.5,
 		anchorY: 0.5,
-		scaleX: 0.5,
-		scaleY: 0.5
+		scaleX: 1,
+		scaleY: 1
 	});
-	eggAsset.tint = 0x66aaff;
 	self.hatched = false;
 	self._hatchTimer = 420 + Math.floor(Math.random() * 180); // 7-10 seconds
 	self.update = function () {
 		if (self.hatched) return;