/**** 
* Classes
****/ 
var Background02 = Container.expand(function () {
	var self = Container.call(this);
	var background02Graphics = self.attachAsset('objBackground02', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add wind animation in the update method
	self.update = function () {
		// Simulate wind blowing by rotating the object slightly
		self.rotation = Math.sin(LK.ticks / 120) * 0.05; // Rotate more back and forth with increased effect
	};
});
var Background04 = Container.expand(function () {
	var self = Container.call(this);
	var background04Graphics = self.attachAsset('objBackground04', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.y += Math.sin(LK.ticks / 60) * 0.2; // Reduced floating effect
	};
});
var Background06 = Container.expand(function () {
	var self = Container.call(this);
	var background06Graphics = self.attachAsset('objBackground06', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.y += Math.sin(LK.ticks / 60) * 0.2; // Reduced floating effect
		self.rotation = Math.sin(LK.ticks / 60) * 0.05 + Math.sin(LK.ticks / 120) * 0.03; // Add a more complex rotation pattern
	};
});
var Background07 = Container.expand(function () {
	var self = Container.call(this);
	var background07Graphics = self.attachAsset('objBackground07', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add wind animation in the update method
	self.update = function () {
		// Simulate wind blowing by rotating the object slightly
		self.rotation = Math.sin(LK.ticks / 120) * 0.08; // Rotate a bit less back and forth
	};
});
var Background13 = Container.expand(function () {
	var self = Container.call(this);
	var background13Graphics = self.attachAsset('objBackground13', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 10;
	self.direction = Math.random() > 0.5 ? 1 : -1; // Randomly choose a direction
	self.update = function () {
		var background13Graphics = self.children[0]; // Access the attached asset
		self.x += self.speed * self.direction;
		// Flip the image depending on the direction
		background13Graphics.scale.x = self.direction * (0.75 + Math.random() * 0.25);
		// Check if background13 is out of bounds horizontally
		if (self.x > 2048 + background13Graphics.width / 2 || self.x < -background13Graphics.width / 2) {
			self.destroy(); // Destroy background13 when it goes out of bounds
			game.background13Active = false; // Reset the flag when objBackground13 is destroyed
		}
	};
});
var ObjCrab = Container.expand(function () {
	var self = Container.call(this);
	var crabGraphics = self.attachAsset('objCrab', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.y = 2400;
	self.speed = 2;
	self.update = function () {
		self.x += self.speed;
		self.y += Math.sin(LK.ticks / 3) * 2; // Add vertical waddling effect
		self.rotation = Math.sin(LK.ticks / 20) * 0.1; // Add rotation for waddling effect
		if (self.intersects(background8) && !self.attached) {
			var objSandDust = game.addChild(new ObjSandDust());
			objSandDust.x = background8.x;
			objSandDust.y = background8.y - 25;
			intersecting = false; // Reset intersecting flag
			self.destroy();
			self.attached = false; // Mark crab as detached when destroyed
		}
		if (objContactPoint.intersects(self)) {
			self.speed = 0;
			self.x = objContactPoint.x;
			self.y = objContactPoint.y;
			self.rotation = 0; // Stop rotation when snatched
			self.attached = true; // Mark crab as snatched
		} else if (self.attached) {
			self.x = objContactPoint.x;
			self.y = objContactPoint.y;
		}
		// Check if objCrab leaves the playspace
		if (self.y > 2732 + self.height || self.y < -self.height || self.x > 2048 + self.width || self.x < -self.width) {
			intersecting = false; // Reset intersecting flag
			self.attached = false; // Mark crab as detached when destroyed
			self.destroy();
		}
	};
});
var ObjFish = Container.expand(function () {
	var self = Container.call(this);
	var fishGraphics = self.attachAsset('objFish', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var startX = 1000; // Centered X position
	var startY = 1875; // Centered Y position
	self.x = startX;
	self.y = startY;
	var scaleDirection = 1;
	self.update = function () {
		// Make the fish swim around its starting position
		var newX = startX + Math.sin(LK.ticks / 60) * 50;
		if (newX < self.x) {
			fishGraphics.scale.x = -1; // Flip horizontally
		} else {
			fishGraphics.scale.x = 1; // Default orientation
		}
		self.x = newX;
		self.y = startY + Math.cos(LK.ticks / 60) * 30;
		// Slowly scale the fish up and down
		if (self.scale.x >= 1.1) {
			scaleDirection = -1;
		} else if (self.scale.x <= 0.9) {
			scaleDirection = 1;
		}
		self.scale.x += scaleDirection * 0.001;
		self.scale.y += scaleDirection * 0.001;
	};
});
var ObjGust = Container.expand(function () {
	var self = Container.call(this);
	var gustGraphics = self.attachAsset('objGust', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.alpha -= 0.02; // Gradually disappear over 0.5 seconds (30 frames)
		if (self.alpha <= 0) {
			intersecting = false; // Reset intersecting flag
			self.destroy(); // Destroy the object when fully transparent
		}
	};
});
var ObjMusicNotes = Container.expand(function () {
	var self = Container.call(this);
	var musicNotesGraphics = self.attachAsset('ObjMusicNotes', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var scaleDirection = 1;
	self.update = function () {
		// Make the music notes dance by scaling up and down slightly
		if (self.scale.y >= 1.1) {
			scaleDirection = -1;
		} else if (self.scale.y <= 0.9) {
			scaleDirection = 1;
		}
		self.scale.y += scaleDirection * 0.002;
	};
});
var ObjSandDust = Container.expand(function () {
	var self = Container.call(this);
	var sandDustGraphics = self.attachAsset('objSandDust', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.alpha = 1.0;
	self.update = function () {
		self.y -= 1; // Move upwards
		self.alpha -= 0.01; // Gradually disappear over 2 seconds (60 frames per second)
		if (self.alpha <= 0) {
			self.destroy(); // Destroy the object when fully transparent
		}
	};
});
var Seagull = Container.expand(function () {
	var self = Container.call(this);
	var seagullGraphics = self.attachAsset('objSeagull', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 10 * Math.pow(1.1, Math.floor(score / 50)) * (1 + Math.floor(score / 50) * 0.1);
	self.direction = 1;
	self.diving = false;
	self.diveTime = 0;
	self.diveDuration = 60; // Total duration of the dive in frames
	self.startX = 0;
	self.startY = 0;
	self.endX = 0;
	self.endY = 2732 - seagullGraphics.height / 2 - 200; // Target Y position for the dive
	self.returning = false;
	self.update = function () {
		if (self.diving) {
			self.diveTime++;
			var t = self.diveTime / self.diveDuration; // Normalized time (0 to 1)
			self.x = (1 - t) * self.startX + t * self.endX; // Linear horizontal movement
			self.y = (1 - t) * self.startY + t * self.endY - 300 * t * (1 - t); // Parabolic vertical movement
			if (!game.background13Active) {
				var background13 = game.addChildAt(new Background13(), game.getChildIndex(self) - 1);
				background13.x = self.x;
				background13.y = self.y;
				game.background13Active = true;
			}
			if (self.diveTime >= self.diveDuration) {
				self.diveTime = 0;
				self.diving = false;
				self.returning = true; // Start returning to original position
				gustSpawned = false; // Reset gustSpawned flag
				self.startX = self.x; // Update startX to the current X
				self.startY = self.y; // Update startY to the current Y (bottom of the dive)
				self.endY = 475; // Return to the original Y position
				self.endX = self.startX + self.speed * self.direction * self.diveDuration / 2; // Move further ahead
			}
		} else if (self.returning) {
			self.diveTime++;
			var t = self.diveTime / self.diveDuration; // Normalized time (0 to 1)
			self.x = (1 - t) * self.startX + t * self.endX; // Linear horizontal movement back
			self.y = (1 - t) * self.startY + t * self.endY - 300 * t * (1 - t); // Parabolic vertical movement back
			if (self.diveTime >= self.diveDuration) {
				self.diveTime = 0;
				self.returning = false; // End the return phase
				self.diving = false; // Reset diving state
				self.startX = self.x; // Reset startX for the next dive
				self.startY = self.y; // Reset startY for the next dive
				self.endY = 2732 - seagullGraphics.height / 2 - 200; // Reset endY for the next dive
			}
		} else {
			intersecting = false;
			self.x += self.speed * self.direction;
			self.y += Math.sin(LK.ticks / 10) * 5; // Add a hover effect
			// Check if seagull is out of bounds horizontally
			if (self.x > 2048 + seagullGraphics.width / 2 || self.x < -seagullGraphics.width / 2) {
				self.direction *= -1; // Flip direction
				self.x = Math.max(-seagullGraphics.width / 2, Math.min(2048 + seagullGraphics.width / 2, self.x)); // Keep seagull within bounds
				self.y = Math.random() * (2732 * 0.3) + 100; // Random Y position in the upper 30% of the playspace with a 100px boundary
				// Flip the seagull's graphics
				seagullGraphics.scale.x *= -1;
			}
		}
		// Increment score by 3 every second objCrab or objFries are intersecting with objContactPoint
		if (LK.ticks % 60 == 0) {
			if (self.x > 2048 + seagullGraphics.width / 2 || self.x < -seagullGraphics.width / 2 || self.y > 2732 + seagullGraphics.height / 2 || self.y < -seagullGraphics.height / 2) {
				intersecting = false; // Reset intersecting flag
				self.attached = false; // Mark seagull as detached when out of bounds
			} else if (objContactPoint.intersects(fries) || typeof crab !== 'undefined' && objContactPoint.intersects(crab)) {
				score += 10;
				self.speed = 10 * Math.pow(1.1, Math.floor(score / 50)) * (1 + Math.floor(score / 50) * 0.1);
			}
		}
		// Update the score display
		scoreText.setText('Score: ' + score);
		// Check if objContactPoint and fries or crab are intersecting
		if (objContactPoint.intersects(fries) || typeof crab !== 'undefined' && objContactPoint.intersects(crab)) {
			intersecting = true;
			// Attach fries or crab to the center of objContactPoint
			if (objContactPoint.intersects(fries)) {
				fries.x = objContactPoint.x;
				fries.y = objContactPoint.y;
			} else if (typeof crab !== 'undefined') {
				crab.speed = 0;
				crab.x = objContactPoint.x;
				crab.y = objContactPoint.y;
				crab.rotation = 0; // Stop rotation when snatched
				crab.attached = true; // Mark crab as snatched
			}
			// Stop decreasing hungerMeter's width and start replenishing it
			var attachedItems = 0;
			if (objContactPoint.intersects(fries)) {
				attachedItems++;
			}
			if (typeof crab !== 'undefined' && objContactPoint.intersects(crab)) {
				attachedItems++;
			}
			if (attachedItems > 0 && (objContactPoint.intersects(fries) || typeof crab !== 'undefined' && objContactPoint.intersects(crab))) {
				hungerMeter.width = Math.min(hungerMeter.width + attachedItems * 3, 2048);
				hungerMeter.tint = 0x90EE90; // Light green color
			} else {
				hungerMeter.width = Math.max(hungerMeter.width - 1.5, 0); // Decrease hunger meter slightly
				hungerMeter.tint = 0xea6262; // Reset to original color
			}
			if (!game.objYum) {
				game.objYum = game.addChild(LK.getAsset('objYum', {
					anchorX: 0.5,
					anchorY: 0.5
				}));
				game.objYum.x = game.objImHungry.x;
				game.objYum.y = game.objImHungry.y;
			}
			if (!game.objStar) {
				game.objStar = game.addChildAt(LK.getAsset('objStar', {
					anchorX: 0.5,
					anchorY: 0.5
				}), game.getChildIndex(head) - 1);
				game.objStar.x = head.x - 35;
				game.objStar.y = head.y + 5;
			}
		} else if (typeof crab !== 'undefined' && crab.attached) {
			crab.x = objContactPoint.x;
			crab.y = objContactPoint.y;
			// Stop decreasing hungerMeter's width and start replenishing it when objCrab is attached
			var attachedItems = 1; // Since crab is attached
			if (objContactPoint.intersects(fries)) {
				attachedItems++;
			}
			if (attachedItems > 0 && (objContactPoint.intersects(fries) || typeof crab !== 'undefined' && objContactPoint.intersects(crab))) {
				hungerMeter.width = Math.min(hungerMeter.width + attachedItems * 3, 2048);
				hungerMeter.tint = 0x90EE90; // Light green color
			}
			if (!game.objYum) {
				game.objYum = game.addChild(LK.getAsset('objYum', {
					anchorX: 0.5,
					anchorY: 0.5
				}));
				game.objYum.x = game.objImHungry.x;
				game.objYum.y = game.objImHungry.y;
				LK.setTimeout(function () {
					game.objYum.destroy();
					game.objYum = null;
				}, 1000); // Display objYum for 1 second
			}
		} else {
			// Decrease hungerMeter's width over time if seagull is not snatching fries or crab
			if (!intersecting && hungerMeter.width > 0) {
				if (hungerMeter.width < 2048 * 0.35 && LK.ticks % 120 == 0) {
					// Trigger shake intermittently every 2 seconds
					screenShake(500, 15); // Shake for 500ms with increased intensity of 15 pixels
				}
				hungerMeter.width -= 1.5; // Decrease the rate of decrease
				hungerMeter.tint = 0xea6262; // Reset to original color
				// Instantiate objImHungry for two seconds over objHead
				if (!game.objImHungry) {
					game.objImHungry = game.addChild(LK.getAsset('objImHungry', {
						anchorX: 0.5,
						anchorY: 0.5
					}));
					game.objImHungry.x = head.x + 150;
					game.objImHungry.y = head.y - 25;
				}
				if (game.objYum) {
					game.objYum.destroy();
					game.objYum = null;
				}
				if (game.objStar) {
					game.objStar.destroy();
					game.objStar = null;
				}
				if (LK.ticks % 60 == 0) {
					score += 3;
					self.speed = 10 * Math.pow(1.1, Math.floor(score / 50)) * (1 + Math.floor(score / 50) * 0.1);
				}
			}
		}
		// Check if fries or crab leave the playspace
		if (fries.y > 2732 + fries.height / 2 || fries.y < -fries.height / 2 || fries.x > 2048 + fries.width / 2 || fries.x < -fries.width / 2) {
			// Destroy fries
			intersecting = false; // Reset intersecting flag
			fries.attached = false; // Mark fries as detached when destroyed
			fries.destroy();
		}
		if (typeof crab !== 'undefined' && (crab.y > 2732 + crab.height / 2 || crab.y < -crab.height / 2 || crab.x > 2048 + crab.width / 2 || crab.x < -crab.width / 2)) {
			intersecting = false; // Reset intersecting flag
			crab.attached = false; // Mark crab as detached when destroyed
			crab.destroy();
		}
		// Initialize objBackground13 every 6 to 15 seconds
		if (!game.background13Active && LK.ticks % (60 * (Math.floor(Math.random() * 10) + 6)) == 0) {
			var background13 = game.addChildAt(new Background13(), game.getChildIndex(seagull) - 1);
			background13.direction = Math.random() > 0.5 ? 1 : -1; // Randomly choose a direction
			background13.x = background13.direction > 0 ? -background13.width / 2 : 2048 + background13.width / 2; // Start from the left or right edge of the playspace
			background13.y = Math.random() * (2732 * 0.2) + 50; // Random Y position in the upper 20% of the playspace with a 50px boundary
			game.background13Active = true; // Set the flag to indicate that objBackground13 is active
			background13.update = function () {
				var background13Graphics = this.children[0]; // Access the attached asset
				this.x += this.speed * this.direction;
				// Flip the image depending on the direction
				background13Graphics.scale.x = this.direction;
				// Check if background13 is out of bounds horizontally
				if (this.x > 2048 + background13Graphics.width / 2 || this.x < -background13Graphics.width / 2) {
					this.destroy(); // Destroy background13 when it goes out of bounds
					game.background13Active = false; // Reset the flag when objBackground13 is destroyed
				}
			};
		}
		// Spawn objCrab every 10 seconds
		if (LK.ticks % (60 * 10) == 0) {
			crab = new ObjCrab();
			crab.attached = false; // Initialize attached state
			crab.x = -crab.width / 2; // Start from the utmost left
			game.addChildAt(crab, game.getChildIndex(background9)); // Add crab behind objBackground09
		}
		// Trigger game over when hungerMeter's width reaches 0
		if (hungerMeter.width <= 0) {
			var redOverlay = game.addChild(LK.getAsset('objRedOverlay', {
				anchorX: 0.5,
				anchorY: 0.5,
				alpha: 0.8
			}));
			redOverlay.x = 1024;
			redOverlay.y = 1366;
			LK.setTimeout(function () {
				var objDizzy = game.addChild(LK.getAsset('objDizzy', {
					anchorX: 0.5,
					anchorY: 0.5
				}));
				objDizzy.x = 1024;
				objDizzy.y = 1366;
				LK.setScore(score);
				scoreText.visible = false; // Set visibility of score to 0 during game over
				LK.showGameOver(); //Calling this will destroy the 'Game' and reset entire game state.
			}, 500); // Delay game over by 0.5 seconds
		}
		// Attach objContactPoint to the center of seagull
		objContactPoint.x = self.x;
		objContactPoint.y = self.y + 200;
	};
	// Remove the down event from the seagull as we want to trigger it from anywhere in the playspace
});
var Smoke = Container.expand(function () {
	var self = Container.call(this);
	var smokeGraphics = self.attachAsset('objSmoke', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.y += Math.sin(LK.ticks / 60) * 0.2; // Reduced floating effect
	};
});

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

/**** 
* Game Code
****/ 
var scaleUp = true;
LK.setInterval(function () {
	if (scaleUp) {
		objRadio.scale.x *= 1.1;
		objRadio.scale.y *= 1.1;
	} else {
		objRadio.scale.x /= 1.1;
		objRadio.scale.y /= 1.1;
	}
	scaleUp = !scaleUp;
}, 500);
function screenShake(duration, intensity) {
	var originalX = game.x;
	var originalY = game.y;
	var shakeInterval = LK.setInterval(function () {
		game.x = originalX + (Math.random() - 0.5) * intensity;
		game.y = originalY + (Math.random() - 0.5) * intensity;
	}, 16); // Shake every frame (60 FPS)
	LK.setTimeout(function () {
		LK.clearInterval(shakeInterval);
		game.x = originalX;
		game.y = originalY;
	}, duration);
}
var crab; // Declare crab in the global scope
var intersecting = false; // Flag to track if seagull is interacting with fries or crab
var crabSmokeInstantiated = false; // Flag to track if objContactSmoke has been instantiated for objCrab
var gustSpawned = false; // Flag to track if objGust has been spawned
var gustCooldown = false; // Flag to track if the cooldown period is active
var background = game.addChild(LK.getAsset('ObjBackground01', {
	anchorX: 0.5,
	anchorY: 0.5
}));
background.x = 1024;
background.y = 1366;
var objSmoke = game.addChild(new Smoke());
objSmoke.x = 975;
objSmoke.y = 875;
var objFish = game.addChild(new ObjFish());
objFish.x = 1024;
objFish.y = 1366; // Position objFish at y 1366
objFish.visible = true; // Ensure objFish is visible
var background11 = game.addChild(LK.getAsset('objBackground11', {
	anchorX: 0.5,
	anchorY: 0.5
}));
background11.x = 25;
background11.y = 1300;
var background10 = game.addChild(LK.getAsset('objBackground10', {
	anchorX: 0.5,
	anchorY: 0.5
}));
// Removed duplicate objRadio instantiation
var objRadio = game.addChild(LK.getAsset('objRadio', {
	anchorX: 0.5,
	anchorY: 0.5
}));
objRadio.x = 265;
objRadio.y = 1165;
var objMusicNotes = new ObjMusicNotes();
game.addChild(objMusicNotes);
objMusicNotes.x = objRadio.x + 165;
objMusicNotes.y = objRadio.y - 75;
background10.x = 125;
background10.y = 2500;
var background9 = game.addChild(LK.getAsset('objBackground09', {
	anchorX: 0.5,
	anchorY: 0.5
}));
background9.x = 450;
background9.y = 2490;
var background8 = game.addChild(LK.getAsset('objBackground08', {
	anchorX: 0.5,
	anchorY: 0.5
}));
background8.x = 1525;
background8.y = 2455;
var background7 = game.addChild(new Background07());
background7.x = 150;
background7.y = 2650;
var background6 = game.addChild(new Background06());
background6.x = 1175;
background6.y = 1035;
var background4 = game.addChild(new Background04());
var background5 = game.addChild(LK.getAsset('objBackground05', {
	anchorX: 0.5,
	anchorY: 0.5
}));
var objRadio = game.addChild(LK.getAsset('objRadio', {
	anchorX: 0.5,
	anchorY: 0.5
}));
objRadio.x = 265;
objRadio.y = 1165;
var background12 = game.addChild(LK.getAsset('objBackground12', {
	anchorX: 0.5,
	anchorY: 0.5
}));
background12.x = 850;
background12.y = 3335;
background5.x = 165;
background5.y = 1925;
background4.x = 1024;
background4.y = 990;
var background3 = game.addChild(LK.getAsset('objBackground03', {
	anchorX: 0.5,
	anchorY: 0.5
}));
background3.x = 1824;
background3.y = 2166;
var background2 = game.addChild(new Background02());
background2.x = 1790;
background2.y = 1766;
var seagull = game.addChild(new Seagull());
intersecting = false; // Reset intersecting flag
crabSmokeInstantiated = false; // Reset crab smoke flag
gustSpawned = false; // Reset gust spawned flag
gustCooldown = false; // Reset gust cooldown flag
seagull.x = -seagull.width / 2; // Start from outside the left edge of the playspace
seagull.y = 475;
if (typeof fries !== 'undefined') {
	fries.attached = false; // Reset attached state for fries
}
if (typeof crab !== 'undefined') {
	crab.attached = false; // Reset attached state for crab
}
// Ensure hunger bar does not refill when a new seagull is instantiated
hungerMeter.width = Math.max(hungerMeter.width - 1.5, 0); // Decrease hunger meter slightly
hungerMeter.tint = 0xea6262; // Reset to original color
var fries = game.addChild(LK.getAsset('objFries', {
	anchorX: 0.5,
	anchorY: 0.5
}));
fries.x = 1024;
fries.y = 2166;
var hungerMeter = game.addChild(LK.getAsset('objHungerMeter', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 2048
}));
hungerMeter.x = 1024;
hungerMeter.y = 2650;
objContactPoint = game.addChild(LK.getAsset('objContactPoint', {
	anchorX: 0.5,
	anchorY: 0.5,
	alpha: 0
}));
objContactPoint.x = 1024;
objContactPoint.y = 1366;
// Create a text object to display the score
var scoreText = new Text2('Score: 0', {
	size: 80,
	fill: "#ffffff",
	font: "Impact"
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
var score = 0;
scoreText.visible = true; // Reset visibility of score to 1 when game starts
game.background13Active = false; // Flag to track if objBackground13 is active
// Instantiate objStomach where objHungerFrame is and remove objHungerFrame from the playspace
var head = game.addChild(LK.getAsset('objHead', {
	anchorX: 0.5,
	anchorY: 0.5
}));
head.x = 1050;
head.y = 2635;
;
game.down = function (x, y, obj) {
	if (!seagull.diving && !seagull.returning) {
		// Only start diving if not already diving or returning
		seagull.diving = true;
		seagull.diveTime = 0;
		seagull.startX = seagull.x;
		seagull.startY = seagull.y;
		// Calculate endX based on current speed and direction
		seagull.endX = seagull.startX + seagull.speed * seagull.direction * seagull.diveDuration / 2;
	}
	if (!gustSpawned && !gustCooldown) {
		// Spawn objGust behind seagull
		var objGust = game.addChildAt(new ObjGust(), game.getChildIndex(seagull));
		objGust.x = seagull.x; // Position at the center of the seagull
		objGust.y = seagull.y;
		LK.setTimeout(function () {
			objGust.destroy();
		}, 100); // Destroy objGust after 0.1 seconds
		gustSpawned = true; // Set gustSpawned flag to true
		gustCooldown = true; // Set gustCooldown flag to true
		LK.setTimeout(function () {
			gustCooldown = false; // Reset gustCooldown flag after 2 seconds
		}, 2000);
	}
};

===================================================================
--- original.js
+++ change.js
@@ -77,9 +77,9 @@
 	self.update = function () {
 		self.x += self.speed;
 		self.y += Math.sin(LK.ticks / 3) * 2; // Add vertical waddling effect
 		self.rotation = Math.sin(LK.ticks / 20) * 0.1; // Add rotation for waddling effect
-		if (self.intersects(background8) && !self.attached && !self.snatched) {
+		if (self.intersects(background8) && !self.attached) {
 			var objSandDust = game.addChild(new ObjSandDust());
 			objSandDust.x = background8.x;
 			objSandDust.y = background8.y - 25;
 			intersecting = false; // Reset intersecting flag
@@ -278,11 +278,14 @@
 			}
 			if (typeof crab !== 'undefined' && objContactPoint.intersects(crab)) {
 				attachedItems++;
 			}
-			if (attachedItems > 0) {
+			if (attachedItems > 0 && (objContactPoint.intersects(fries) || typeof crab !== 'undefined' && objContactPoint.intersects(crab))) {
 				hungerMeter.width = Math.min(hungerMeter.width + attachedItems * 3, 2048);
 				hungerMeter.tint = 0x90EE90; // Light green color
+			} else {
+				hungerMeter.width = Math.max(hungerMeter.width - 1.5, 0); // Decrease hunger meter slightly
+				hungerMeter.tint = 0xea6262; // Reset to original color
 			}
 			if (!game.objYum) {
 				game.objYum = game.addChild(LK.getAsset('objYum', {
 					anchorX: 0.5,
@@ -298,17 +301,17 @@
 				}), game.getChildIndex(head) - 1);
 				game.objStar.x = head.x - 35;
 				game.objStar.y = head.y + 5;
 			}
-		} else if (typeof crab !== 'undefined' && crab.attached && intersecting) {
+		} else if (typeof crab !== 'undefined' && crab.attached) {
 			crab.x = objContactPoint.x;
 			crab.y = objContactPoint.y;
 			// Stop decreasing hungerMeter's width and start replenishing it when objCrab is attached
 			var attachedItems = 1; // Since crab is attached
 			if (objContactPoint.intersects(fries)) {
 				attachedItems++;
 			}
-			if (attachedItems > 0) {
+			if (attachedItems > 0 && (objContactPoint.intersects(fries) || typeof crab !== 'undefined' && objContactPoint.intersects(crab))) {
 				hungerMeter.width = Math.min(hungerMeter.width + attachedItems * 3, 2048);
 				hungerMeter.tint = 0x90EE90; // Light green color
 			}
 			if (!game.objYum) {
@@ -566,8 +569,11 @@
 }
 if (typeof crab !== 'undefined') {
 	crab.attached = false; // Reset attached state for crab
 }
+// Ensure hunger bar does not refill when a new seagull is instantiated
+hungerMeter.width = Math.max(hungerMeter.width - 1.5, 0); // Decrease hunger meter slightly
+hungerMeter.tint = 0xea6262; // Reset to original color
 var fries = game.addChild(LK.getAsset('objFries', {
 	anchorX: 0.5,
 	anchorY: 0.5
 }));