/**** 
* Classes
****/ 
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinGraphics = self.attachAsset('Coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Initialize coin properties
	self.rotationSpeed = 0.05; // Rotation speed for the coin
	self.speedX = -5; // Speed of the coin moving left
	self.collecting = false; // Flag to check if the coin is being collected
	self.targetX = 0; // Target X position for collection animation
	self.targetY = 0; // Target Y position for collection animation
	self.update = function () {
		// Generate GoldSparkle particles
		if (Math.random() < 0.075) {
			// Reduced chance by 25%
			// 10% chance to generate a sparkle each update
			var sparkle = new GoldSparkle();
			sparkle.x = self.x + (Math.random() * coinGraphics.width - coinGraphics.width / 2);
			sparkle.y = self.y + (Math.random() * coinGraphics.height - coinGraphics.height / 2);
			game.addChild(sparkle);
		}
		// Removed rotation effect from the coin
		// Move the coin left
		self.x += self.speedX * gameSpeed;
		// Apply spin effect over Y axis
		coinGraphics.scale.x = Math.sin(self.x * 0.015);
		// If the coin is being collected, animate it
		if (self.collecting) {
			self.x += (self.targetX - self.x) * 0.1;
			self.y += (self.targetY - self.y) * 0.1;
			coinGraphics.scale.x *= 0.90;
			coinGraphics.scale.y *= 0.90;
			// Check if the coin has reached the target position or is small enough
			if (Math.abs(self.x - self.targetX) < 5 && Math.abs(self.y - self.targetY) < 5 || coinGraphics.scale.x < 0.1 && coinGraphics.scale.y < 0.1) {
				self.destroy();
				coinCount++;
				coinCounter.setText(coinCount.toString());
				coinIcon.x = -coinCounter.width - 10; // Update coin icon position based on counter width
				return; // Ensure no further updates after destruction
			}
		}
		// Destroy the coin if it goes off screen
		if (self.x < -coinGraphics.width / 2 && !self.collecting) {
			self.destroy();
			return; // Ensure no further updates after destruction
		}
	};
});
var CollisionBlock = Container.expand(function () {
	var self = Container.call(this);
	var collisionBlockGraphics = self.attachAsset('Collisionblock', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
});
// Assets will be automatically created and loaded by the LK engine based on their usage in the code.
// Example assets: 'coot', 'obstacle', 'background'
// Class for the main character, the American coot
var Coot = Container.expand(function () {
	var self = Container.call(this);
	var cootGraphics = self.attachAsset('coot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.originalX = self.x; // Store original X position
	self.speed = 6.5;
	self.dashSpeed = 15;
	self.lives = 3; // Initialize Coot with three lives
	self.dashDelay = 30;
	self.isDashing = false;
	self.dashTimer = 0;
	self.jumpVelocity = 40; // Increased initial upward velocity for jump
	self.gravity = 1.0; // Gravity to apply during jump
	self.jumpHeight = 105;
	self.isJumping = false;
	self.isReturning = false; // New state to handle returning to top after diving
	self.isInvincible = false; // Initialize invincible state
	self.update = function () {
		if (self.isJumping) {
			self.x += self.speed * 0.1 * gameSpeed;
			self.y -= self.jumpVelocity; // Move upwards with initial velocity
			self.jumpVelocity -= self.gravity; // Apply gravity to slow down ascent
			if (self.jumpVelocity <= 0) {
				self.isJumping = false; // Stop jumping when upward velocity is zero
				self.isFalling = true; // Start falling
			}
		} else if (self.isFalling) {
			self.y += self.gravity * 7; // Apply even more increased gravity to fall down faster
			if (self.y >= self.originalY) {
				self.y = self.originalY; // Ensure Coot doesn't go below original position
				self.isFalling = false; // Stop falling
				self.x = self.originalX; // Reset X position when jump completes
				self.jumpVelocity = 40; // Reset jump velocity for next jump
				self.isJumping = false; // Ensure jumping state is reset
				// Removed unnecessary isReturning reset in the falling state
			}
			// Remove wobble and water particles during falling
			cootGraphics.rotation = 0; // Reset rotation to remove wobble
		} else if (self.isDiving) {
			self.y += self.speed * 1.5;
			cootGraphics.alpha = Math.max(0.5, cootGraphics.alpha - 0.05); // Gradually decrease opacity
			cootGraphics.tint = 0x0000ff; // Change tint to blue
			if (self.y >= 2732 * 0.90) {
				self.y = 2732 * 0.90; // Ensure Coot doesn't go below this point
				self.isDiving = false; // Stop diving
				self.returnDelay = Date.now() + 1000; // 1 second delay using time
			}
		} else if (self.returnDelay > 0) {
			if (Date.now() >= self.returnDelay) {
				self.returnDelay = 0; // Reset returnDelay after it is used
				if (self.y >= 2732 * 0.90) {
					self.isReturning = true; // Start returning after delay
				}
			}
		} else if (self.isReturning) {
			self.y -= self.speed * 1.5; // Match surfacing speed with descent speed
			var transitionFactor = 1 - (self.y - self.originalY) / (2732 * 0.90 - self.originalY);
			cootGraphics.alpha = 0.5 + 0.5 * transitionFactor; // Smoothly increase opacity
			// Convert tint colors to RGB and interpolate
			var startTint = self.underwaterTint;
			var endTint = 0xffffff;
			var r = (startTint >> 16 & 0xff) + ((endTint >> 16 & 0xff) - (startTint >> 16 & 0xff)) * transitionFactor;
			var g = (startTint >> 8 & 0xff) + ((endTint >> 8 & 0xff) - (startTint >> 8 & 0xff)) * transitionFactor;
			var b = (startTint & 0xff) + ((endTint & 0xff) - (startTint & 0xff)) * transitionFactor;
			cootGraphics.tint = (r << 16) + (g << 8) + b; // Apply interpolated tint
			if (self.y <= self.originalY) {
				self.y = self.originalY;
				self.isReturning = false; // Reset returning state
				cootGraphics.alpha = 1.0; // Ensure opacity is fully reset
				cootGraphics.tint = 0xffffff; // Reset tint to normal color when fully surfaced
			}
			// Removed redundant isReturning block to ensure visual effects are not reset prematurely
			if (self.isReturning) {
				self.x += (self.originalX - self.x) * 0.1; // Gradually slide back to original X position
			}
		}
		// Add wobble effect to the coot while running
		if (!self.isJumping && !self.isDiving && !self.isReturning && !self.isFalling) {
			cootGraphics.rotation = Math.sin(LK.ticks / 5) * 0.1; // Increase wobble speed by reducing the divisor
			// Generate 1-2 water splash particles every 60 ticks (1 second) only when not jumping, diving, or falling
			if (!self.isJumping && !self.isDiving && !self.isFalling && LK.ticks % 60 == 0) {
				var numParticles = Math.floor(Math.random() * 2) + 1;
				for (var i = 0; i < numParticles; i++) {
					var splashLeft = new Splash();
					splashLeft.x = self.x - cootGraphics.width / 2;
					splashLeft.y = self.y + cootGraphics.height / 2;
					game.addChildAt(splashLeft, game.getChildIndex(foreground1) - 1);
					var splashRight = new Splash();
					splashRight.x = self.x + cootGraphics.width / 2;
					splashRight.y = self.y + cootGraphics.height / 2;
					game.addChildAt(splashRight, game.getChildIndex(foreground1) - 1);
				}
			}
		}
		// Handle dash state
		if (self.isDashing) {
			if (self.dashTimer < self.dashDelay) {
				// Dash forward
				if (self.x < 2048 * 0.75) {
					// Stop at 3/4 of screen width
					self.x += self.dashSpeed;
				}
				self.dashTimer++;
			} else {
				// Return to original position
				if (self.x > self.originalX) {
					self.x -= self.dashSpeed / 2; // Return at half speed
				} else {
					self.x = self.originalX;
					self.isDashing = false;
					self.dashTimer = 0;
				}
			}
		}
	};
	self.isDiving = false;
	self.isDashing = false;
	self.dashSpeed = 15;
	self.dashDelay = 60; // frames before return (1 second at 60fps)
	self.dashTimer = 0;
	self.originalX = self.x; // Store original position
	self.jump = function () {
		if (!self.isJumping && !self.isDiving && !self.isReturning && !self.isDashing) {
			self.isJumping = true;
			self.originalX = self.x;
			// Removed X position update from jump function
			self.isReturning = false; // Ensure returning state is reset when jumping
			self.originalY = self.y;
		}
	};
	self.dash = function () {
		if (!self.isJumping && !self.isDiving && !self.isReturning && !self.isDashing) {
			self.isDashing = true;
			self.originalX = self.x;
			self.dashTimer = 0;
		}
	};
	self.dive = function () {
		if (!self.isJumping && !self.isDiving && !self.isDashing) {
			self.isDiving = true;
			self.returnDelay = Date.now() + 5000; // Set return delay to 5 seconds using time
			self.isReturning = false; // Ensure returning state is reset when diving
			self.underwaterTint = 0x4444ff; // Set initial underwater tint color
			// Removed duplicate isReturning = false line
			self.originalX = self.x;
			self.originalY = self.y;
			self.y += self.speed * 2; // Start diving downwards immediately with increased speed
			// Generate water splash particles
			var numParticles = Math.floor(Math.random() * 3) + 2; // Generate 2-4 particles
			for (var i = 0; i < numParticles; i++) {
				var splash = new Splash();
				splash.x = self.x;
				splash.y = self.y + cootGraphics.height / 2;
				game.addChildAt(splash, game.getChildIndex(foreground1) - 1);
			}
		}
	};
});
var EagleFeather = Container.expand(function () {
	var self = Container.call(this);
	var featherGraphics = self.attachAsset('Eaglefeather', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Initialize feather properties
	self.rotationSpeed = Math.random() * 0.02 - 0.01; // Random rotation speed
	self.driftX = Math.random() * 2 - 1; // Random sideways drift
	self.driftY = Math.random() * -1 - 0.5; // Upward drift
	self.fadeRate = 0.005; // Fade out rate
	self.update = function () {
		self.x += self.driftX * gameSpeed;
		self.y += self.driftY * gameSpeed;
		featherGraphics.rotation += self.rotationSpeed;
		featherGraphics.alpha -= self.fadeRate;
		// Destroy feather when fully faded
		if (featherGraphics.alpha <= 0) {
			self.destroy();
		}
	};
});
// Class for the foreground
var Foreground = Container.expand(function () {
	var self = Container.call(this);
	var foregroundGraphics = self.attachAsset('Foreground', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	self.isFirst = false; // Will be set during initialization
	self.update = function () {
		// Only move the first piece
		if (self.isFirst) {
			self.x -= self.speed * gameSpeed; // Apply gameSpeed to movement
			// Move second piece to maintain fixed distance
			self.other.x = self.x + self.width;
			// Reset both pieces when first goes off screen
			if (self.x < -self.width / 1.5) {
				// Reset earlier - when piece is mostly off screen
				self.x += self.width;
				self.other.x = self.x + self.width;
			}
		}
	};
});
var GoldSparkle = Container.expand(function () {
	var self = Container.call(this);
	var sparkleGraphics = self.attachAsset('GoldSparkle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speedX = (Math.random() * 2 - 1) * 0.75; // Reduced horizontal speed by 25%
	self.speedY = (Math.random() * 2 - 1) * 0.75; // Reduced vertical speed by 25%
	self.fadeRate = 0.02; // Rate at which the sparkle fades
	self.update = function () {
		self.x += self.speedX;
		self.y += self.speedY;
		sparkleGraphics.alpha -= self.fadeRate;
		if (sparkleGraphics.alpha <= 0) {
			self.destroy();
		}
	};
});
// Class for the midgroundtrees
var Midgroundtrees = Container.expand(function () {
	var self = Container.call(this);
	var midgroundtreesGraphics = self.attachAsset('Midgroundtrees', {
		anchorX: 0.5,
		anchorY: 0.7
	});
	self.speed = 3;
	self.update = function () {
		self.x -= self.speed * gameSpeed;
		// self.y = coot.y;
		if (self.x <= -self.width / 2) {
			self.x += self.width * 2;
		}
	};
});
// Class for the Obstacle (Duck, Eagle, and Fish combined)
var Obstacle = Container.expand(function (type) {
	var self = Container.call(this);
	var graphics;
	var collisionBlock = self.addChild(new CollisionBlock());
	collisionBlock.x = 0;
	collisionBlock.y = 0;
	graphics = self.attachAsset(type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add a Ripple instance to the Duck obstacle
	if (type === 'Duck') {
		self.lastRippleTime = Date.now();
		var ripple = new Ripple();
		ripple.x = 0; // Center the ripple on the Duck
		ripple.y = graphics.height / 2; // Position the ripple at the bottom of the Duck
		self.addChildAt(ripple, 0); // Add ripple below the Duck but above the water layer
	}
	self.speedX = -6;
	if (type === 'Fish') {
		self.isJumping = false;
		self.pauseTime = 0;
		graphics.tint = 0x4444ff;
		graphics.alpha = 0.7;
	}
	if (type === 'Fish') {
		self.speedX = -6; // Back to original fast swimming speed
		self.jumpSpeed = 0.05; // Slow jump speed control
		self.isJumping = false;
		self.isPausing = false;
		self.pauseTime = 0;
		self.lastSplashTime = Date.now(); // Add splash timer
		graphics.tint = 0x4444ff; // Set underwater blue tint initially
		graphics.alpha = 0.7; // Set underwater opacity initially
		self.isFalling = false;
		self.jumpVelocity = 0;
		self.jumpStartY = self.y; // Store original position
		self.jumpTime = 0; // Initialize jump time counter
		self.y = 2732 * 0.90; // Set Fish Y position to the bottom of the Coot's dive
	}
	if (type === 'Eagle') {
		self.lastFeatherTime = Date.now();
		self.targetY = coot.isDiving || coot.isReturning ? coot.originalY : coot.y;
		self.speedY = (self.targetY - self.y) / 100;
		self.speedX = -8; // Add horizontal speed variable for eagle
	}
	self.update = function () {
		self.x += self.speedX * gameSpeed;
		if (type === 'Fish') {
			// Move horizontally
			self.x += self.speedX;
			// Generate underwater splash effects
			if (!self.isJumping && Date.now() - self.lastSplashTime >= 200) {
				// Generate every 200ms
				var numSplashes = Math.floor(Math.random() * 2) + 1; // 1-2 splashes
				for (var i = 0; i < numSplashes; i++) {
					var splash = new Splash();
					splash.x = self.x + (Math.random() * graphics.width - graphics.width / 2); // Random position along fish body
					splash.y = self.y;
					splash.tint = 0x4444ff; // Match fish's underwater tint
					game.addChildAt(splash, game.getChildIndex(self) - 1);
				}
				self.lastSplashTime = Date.now();
			}
			// Check if crossing under Coot
			if (self.x <= coot.x && !self.isJumping) {
				self.speedX = 0;
				graphics.alpha = 0;
				self.pauseTime += 0.02; // Increase pause time by reducing increment rate
			}
			// Add this check for when to reappear
			if (self.pauseTime >= 1 && !self.isJumping) {
				graphics.alpha = 1;
				graphics.rotation = Math.PI / 2; // Changed from -Math.PI/2 to rotate the other way
				self.isJumping = true;
				self.jumpStartY = self.y;
				self.jumpTime = 0;
			}
			// Handle jumping motion
			if (self.isJumping) {
				self.jumpTime += self.jumpSpeed; // Use slower jumpSpeed
				var jumpHeight = -Math.sin(self.jumpTime) * 600; // Changed from 300 to 600
				self.y = self.jumpStartY + jumpHeight;
				// Generate bigger splash burst when jumping out
				if (self.jumpTime < 0.1) {
					// Only on first frame of jump
					var burstSplashes = Math.floor(Math.random() * 4) + 6; // 6-9 splashes (increased from 4-6)
					for (var i = 0; i < burstSplashes; i++) {
						var splash = new Splash();
						splash.x = self.x + (Math.random() * graphics.width - graphics.width / 2);
						splash.y = self.jumpStartY - Math.random() * 200; // Make splashes go higher
						game.addChildAt(splash, game.getChildIndex(self) - 1);
					}
				}
				// Change tint based on height above water
				if (self.y < self.jumpStartY - 50) {
					graphics.tint = 0xffffff; // Normal color above water
					graphics.alpha = 1.0;
				} else {
					graphics.tint = 0x4444ff; // Blue tint in water
					graphics.alpha = 0.7;
				}
				if (self.jumpTime > Math.PI) {
					Obstacle.lastDestroyTime = Date.now();
					console.log("Fish destroyed after jump at " + Date.now());
					currentObstacle = null; // Add this line
					self.destroy();
				}
			}
			// Normal destroy check
			if (self.x <= -self.width / 2) {
				self.destroy();
				Obstacle.lastDestroyTime = Date.now();
			}
		} else if (type === 'Eagle') {
			self.y += self.speedY;
			if (Date.now() - self.lastFeatherTime >= 900) {
				// Feather spawn every 900ms
				var numFeathers = Math.floor(Math.random() * 2) + 2; // Spawn 2-3 feathers
				for (var i = 0; i < numFeathers; i++) {
					var feather = new EagleFeather();
					feather.x = self.x + (Math.random() * 20 - 10); // Slight horizontal variation
					feather.y = self.y + graphics.height / 2;
					game.addChildAt(feather, game.getChildIndex(self) - 1);
				}
				self.lastFeatherTime = Date.now();
			}
			if (self.x <= -self.width / 2) {
				console.log("Checking for destruction: Eagle at " + self.x);
				self.destroy(); // Destroy the obstacle when it moves off-screen
				Obstacle.lastDestroyTime = Date.now(); // Set lastDestroyTime when destroyed
				console.log("Obstacle destroyed at " + Obstacle.lastDestroyTime);
			}
			if (type === 'Eagle') {
				self.targetY = coot.originalY;
				self.speedY = (self.targetY - self.y) / 50;
			}
		} else if (type === 'Duck') {
			// Add wobble effect to Duck
			graphics.rotation = Math.sin(LK.ticks / 20) * 0.05;
			// Ripple spawn logic
			if (Date.now() - self.lastRippleTime >= 500) {
				var ripple = new Ripple();
				ripple.x = self.x;
				ripple.y = self.y + graphics.height / 2;
				game.addChildAt(ripple, game.getChildIndex(self) - 1);
				self.lastRippleTime = Date.now();
			}
			// Existing destroy logic
			if (self.x <= -self.width / 2) {
				console.log("Checking for destruction: Duck at " + self.x);
				self.destroy();
				Obstacle.lastDestroyTime = Date.now();
				console.log("Obstacle destroyed at " + Obstacle.lastDestroyTime);
			}
		}
		collisionBlock.x = 0;
		collisionBlock.y = 0;
	};
});
var Ripple = Container.expand(function () {
	var self = Container.call(this);
	var rippleGraphics = self.attachAsset('Ripple', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.initialScale = 0.05;
	self.growthRate = 0.02;
	self.fadeRate = 0.01;
	self.maxScale = 2.0;
	rippleGraphics.scaleX = self.initialScale;
	rippleGraphics.scaleY = self.initialScale;
	self.update = function () {
		console.log("Ripple update called");
		rippleGraphics.scaleX += self.growthRate;
		rippleGraphics.scaleY += self.growthRate;
		rippleGraphics.alpha -= self.fadeRate;
		console.log("Ripple scale:", rippleGraphics.scaleX, "Ripple alpha:", rippleGraphics.alpha);
		if (rippleGraphics.scaleX >= self.maxScale || rippleGraphics.alpha <= 0) {
			console.log("Ripple destroyed");
			self.destroy();
		}
	};
});
// Static respawn delay property
// Class for the water splash particles
var Splash = Container.expand(function () {
	var self = Container.call(this);
	var scale = Math.random() * 0.75 + 0.25;
	var splashGraphics = self.attachAsset('Watersplash', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: scale,
		scaleY: scale
	});
	self.speedX = Math.random() * 2 - 1; // Random speed in X direction
	self.speedY = -Math.random() * 5; // Random upward speed in Y direction
	self.gravity = 0.1; // Gravity to pull the particle down
	self.update = function () {
		self.x += self.speedX * gameSpeed;
		self.y += self.speedY * gameSpeed;
		self.speedY += self.gravity; // Apply gravity
		// Add rotation based on the speed of the particle
		self.rotation += self.speedX / 10;
		if (self.y > 2732) {
			// If the particle is below the screen
			self.destroy(); // Destroy the particle
		}
	};
});
// Class for the water
var Water = Container.expand(function () {
	var self = Container.call(this);
	var waterGraphics = self.attachAsset('Water', {
		anchorX: 0.5,
		anchorY: 0.7
	});
	self.speed = 2;
	self.update = function () {
		self.x -= self.speed * gameSpeed;
		// self.y = midgroundtrees1.y + midgroundtrees1.height / 2;
		if (self.x <= -self.width / 2) {
			self.x += self.width * 2;
		}
	};
});

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

/**** 
* Game Code
****/ 
Obstacle.getRandomDelay = function (min, max) {
	return Math.floor(Math.random() * (max - min + 1)) + min;
};
Obstacle.spawnDelay = 10000; // Initialize default spawn delay to 10 seconds
Obstacle.respawnDelay = {
	Eagle: Obstacle.getRandomDelay(4000, 6000),
	Duck: Obstacle.getRandomDelay(4000, 6000),
	Fish: Obstacle.getRandomDelay(4000, 6000) // Add Fish delay
};
Obstacle.lastDestroyTime = Date.now() - 5000; // Initialize to ensure first spawn check passes
console.log("Initial lastDestroyTime: " + Obstacle.lastDestroyTime);
var background = game.addChild(LK.getAsset('Background', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2,
	scaleX: 2048 / 2500,
	scaleY: 2732 / 2500
}));
// Initialize the midgroundtrees
var midgroundtrees1 = game.addChild(new Midgroundtrees());
midgroundtrees1.x = 2048 / 2;
midgroundtrees1.y = 2732 * 0.7;
var midgroundtrees2 = game.addChild(new Midgroundtrees());
midgroundtrees2.x = 2048 / 2 + midgroundtrees2.width;
midgroundtrees2.y = 2732 * 0.7;
// Initialize the water
var water1 = game.addChild(new Water());
water1.x = 2048 / 2;
water1.y = midgroundtrees1.y + midgroundtrees1.height / 2;
var water2 = game.addChild(new Water());
water2.x = 2048 / 2 + water2.width;
water2.y = midgroundtrees2.y + midgroundtrees2.height / 2;
// Initialize game variables
var coot = game.addChild(new Coot());
coot.x = 2048 * 0.20;
coot.y = 2732 * 0.75;
coot.originalX = coot.x; // Initialize originalX position
coot.originalY = coot.y; // Initialize originalY position
var gameSpeed = 1.2; // Global variable for game speed
var speedIncreaseInterval = 20000; // 20 seconds in milliseconds
var maxGameSpeed = 3.0; // Maximum game speed
var lastSpeedIncreaseTime = Date.now(); // Track the last time speed was increased
var score = 0;
var coinCount = 0; // Global variable to keep track of collected coins
var currentObstacle = null;
// Initialize the foreground
var foreground1 = new Foreground();
var foreground2 = new Foreground();
game.addChild(foreground1);
game.addChild(foreground2);
foreground1.x = 2048 / 2;
foreground1.y = 2732 * 0.9;
foreground2.x = foreground1.x + foreground1.width;
foreground2.y = 2732 * 0.9;
foreground1.isFirst = true;
foreground1.other = foreground2;
foreground2.other = foreground1;
// Validate positioning
if (Math.abs(foreground2.x - (foreground1.x + foreground1.width)) > 1) {
	console.error("Foreground pieces are not correctly positioned!");
}
foreground1.other = foreground2;
foreground2.other = foreground1;
game.addChild(foreground1);
game.addChild(foreground2);
// Add coin counter display
var coinCounter = new Text2('0', {
	size: 150,
	// Increased size for better visibility
	fill: "#ffffff"
});
coinCounter.anchor.set(1, 0); // Anchor to the top right corner
// Add coin asset beside the coin counter
var coinIcon = LK.getAsset('Coin', {
	anchorX: 1,
	anchorY: 0,
	x: -coinCounter.width - 10,
	// Position to the left of the counter with some padding
	y: 0
});
LK.gui.topRight.addChild(coinIcon);
LK.gui.topRight.addChild(coinCounter);
// Add heart icons to represent Coot's lives
var heartIcons = [];
for (var i = 0; i < coot.lives; i++) {
	var heartIcon = LK.getAsset('HeartLife', {
		anchorX: 0,
		anchorY: 0,
		x: -coinCounter.width - 10 - i * 110,
		// Position hearts in a row with some padding
		y: coinIcon.height + 10 // Position below the coin icon
	});
	LK.gui.topRight.addChild(heartIcon);
	heartIcons.push(heartIcon);
}
game.update = function () {
	coot.update();
	// Increase game speed every 20 seconds
	if (Date.now() - lastSpeedIncreaseTime >= speedIncreaseInterval) {
		if (gameSpeed < maxGameSpeed) {
			gameSpeed = Math.min(gameSpeed + 0.1, maxGameSpeed);
		}
		lastSpeedIncreaseTime = Date.now();
	}
	// Removed the timer counter increment and display logic
	// Check for collision between the Coot and the Collision Block of the current obstacle
	if (currentObstacle && coot.intersects(currentObstacle.children[0])) {
		LK.showGameOver();
	}
	// Update the midgroundtrees
	midgroundtrees1.update();
	midgroundtrees2.update();
	// Update the water
	water1.update();
	water2.update();
	// Update the current obstacle
	// Check if the current obstacle needs destruction
	if (currentObstacle && currentObstacle.x < -currentObstacle.width / 2) {
		currentObstacle.destroy();
		Obstacle.lastDestroyTime = Date.now();
		console.log("Obstacle destroyed at " + Obstacle.lastDestroyTime);
		currentObstacle = null;
	}
	// Check if it's time to spawn a new obstacle
	if (!currentObstacle && Date.now() - Obstacle.lastDestroyTime >= Obstacle.spawnDelay) {
		var obstacleTypes = ['Duck', 'Eagle', 'Fish']; // Ensure equal chance for all types
		var randomIndex = Math.floor(Math.random() * obstacleTypes.length);
		var obstacleType = obstacleTypes[randomIndex];
		console.log("Selected obstacle type: ", obstacleType);
		currentObstacle = game.addChild(new Obstacle(obstacleType));
		currentObstacle.x = 2048 + currentObstacle.width / 2; // Ensure it starts off-screen
		currentObstacle.y = obstacleType === 'Duck' ? 2732 * 0.75 : obstacleType === 'Eagle' ? 2732 * 0.25 : 2732 * 0.85; // Changed from 0.90 to 0.85 for Fish
		console.log("Spawned " + obstacleType + " at " + Date.now());
	}
	if (currentObstacle) {
		currentObstacle.update();
	}
	// Check for collision between the Coot and Coins
	game.children.forEach(function (child) {
		if (child instanceof Coin && coot.intersects(child) && !child.collecting) {
			child.collecting = true;
			child.targetX = 2048 - coinCounter.width - coinIcon.width - 20; // Adjusted to account for padding and counter width
			child.targetY = coinIcon.y + coinIcon.height / 2; // Center vertically on the coin icon
		}
	});
	// Update the foreground
	foreground1.update();
	foreground2.update();
	// Spawn coins randomly
	if (LK.ticks % 120 == 0) {
		// Every 2 seconds at 60 FPS
		var newCoin = new Coin();
		newCoin.x = 2048 + newCoin.width / 2; // Start off-screen to the right
		newCoin.y = Math.random() * (2732 * 0.45) + 2732 * 0.35; // Random Y position between 35% and 80% of the screen height
		game.addChild(newCoin);
	}
};
// Handle touch events for jumping and diving
game.down = function (x, y, obj) {
	dragStartY = y; // Record the initial y position when touch starts
	dragStartX = x; // Record the initial x position when touch starts
};
game.move = function (x, y, obj) {
	if (dragStartY !== null && dragStartX !== null) {
		if (x - dragStartX > 50) {
			// Check if the drag is rightward and significant
			coot.isDashing = true;
			dragStartX = null; // Reset dragStartX to prevent repeated dashes
		}
		if (y - dragStartY > 50 && coot.y === coot.originalY) {
			// Check if the drag is downward and significant
			coot.dive();
			dragStartY = null; // Reset dragStartY to prevent repeated dives
		} else if (dragStartY - y > 50 && coot.y === coot.originalY) {
			// Check if the drag is upward and significant
			coot.jump();
			dragStartY = null; // Reset dragStartY to prevent repeated jumps
		}
	}
};
game.up = function (x, y, obj) {
	dragStartY = null; // Reset dragStartY when touch ends
	dragStartX = null; // Reset dragStartX when touch ends
};