/**** 
* Classes
****/ 
// Class for the CollisionBlock
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.speed = 6.5;
	self.jumpHeight = 105;
	self.isJumping = false;
	self.update = function () {
		if (self.isJumping) {
			self.y -= self.speed;
			if (self.y <= 2732 / 2 - self.jumpHeight) {
				self.isJumping = false;
			}
		} else if (self.isDiving) {
			self.y += self.speed * 1.5;
			if (self.y >= 2732 * 0.90) {
				LK.setTimeout(function () {
					self.isDiving = false;
				}, 500); // Pause for 0.5 seconds at the bottom of the dive
			}
		} else if (!self.isJumping && !self.isDiving) {
			if (self.y < self.originalY) {
				self.y += self.speed; // Return to original position at normal speed
				if (self.y > self.originalY) {
					self.y = self.originalY;
				}
			} else if (self.y > self.originalY) {
				self.y -= self.speed; // Move upwards to original position
				if (self.y < self.originalY) {
					self.y = self.originalY;
				}
			}
			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) {
			cootGraphics.rotation = Math.sin(LK.ticks / 10) / 10;
			// Generate 1-2 water splash particles every 60 ticks (1 second)
			if (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);
				}
			}
		}
	};
	self.isDiving = false;
	self.jump = function () {
		if (!self.isJumping && !self.isDiving) {
			self.isJumping = true;
			self.originalX = self.x;
			self.x += (self.originalX + 2048 * 0.10 - self.x) * 0.1; // Gradually move forward by 10% of the screen width
			self.originalY = self.y;
		}
	};
	self.dive = function () {
		if (!self.isJumping && !self.isDiving) {
			self.isDiving = true;
			self.originalX = self.x;
			self.originalY = self.y;
			self.y += self.speed * 2; // Start diving downwards immediately with increased speed
		}
	};
});
// Class for the Duck obstacle
var Duck = Container.expand(function () {
	var self = Container.call(this);
	var duckGraphics = self.attachAsset('Duck', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 6;
	self.update = function () {
		self.x -= self.speed;
		if (self.x <= -self.width / 2) {
			self.x = 2048 + self.width / 2;
			LK.setTimeout(function () {
				loadRandomObstacle();
			}, Math.random() * 1000 + 500);
		}
	};
});
// Function to randomly select and load an obstacle
// Class for the Eagle obstacle
var Eagle = Container.expand(function () {
	var self = Container.call(this);
	var eagleGraphics = self.attachAsset('Eagle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speedX = -6;
	self.targetY = coot.y;
	self.speedY = (self.targetY - self.y) / 100;
	self.update = function () {
		self.x += self.speedX;
		self.y += self.speedY;
		if (self.x <= -self.width / 2) {
			self.x = 2048 + self.width / 2;
			LK.setTimeout(function () {
				loadRandomObstacle();
			}, Math.random() * 1000 + 500);
		}
		if (self.y < self.targetY) {
			self.speedY = (self.targetY - self.y) / 100;
		} else {
			self.speedY = 0;
		}
	};
});
// 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.update = function () {
		self.x -= self.speed;
		if (self.x <= -self.width / 2) {
			self.x += self.width * 2;
		}
	};
});
// 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;
		// self.y = coot.y;
		if (self.x <= -self.width / 2) {
			self.x += self.width * 2;
		}
	};
});
// 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;
		self.y += self.speedY;
		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;
		// 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
****/ 
// Function to randomly select and load an obstacle
function loadRandomObstacle() {
	var delay = Math.random() * 1000 + 500; // Delay between 0.5 to 1.5 seconds
	LK.setTimeout(function () {
		if (currentObstacle && currentObstacle.x <= -currentObstacle.width / 2) {
			currentObstacle.destroy();
			initializeObstacle();
		}
	}, delay);
}
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.originalY = coot.y; // Initialize originalY position
var score = 0;
var currentObstacle = null;
function initializeObstacle() {
	var obstacleType = Math.random() < 0.5 ? 'Duck' : 'Eagle';
	if (obstacleType === 'Duck') {
		currentObstacle = game.addChild(new Duck());
		currentObstacle.x = 2048;
		currentObstacle.y = 2732 * 0.75;
	} else {
		currentObstacle = game.addChild(new Eagle());
		currentObstacle.x = 2048;
		currentObstacle.y = -currentObstacle.height / 2;
	}
}
initializeObstacle();
// Attach a collision block on top of the duck
var collisionBlockDuck = game.addChild(new CollisionBlock());
if (currentObstacle) {
	collisionBlockDuck.x = currentObstacle.x;
	collisionBlockDuck.y = currentObstacle.y - currentObstacle.height / 2 - collisionBlockDuck.height / 2;
}
// Attach a collision block on top of the eagle
var collisionBlockEagle = game.addChild(new CollisionBlock());
LK.setTimeout(function () {
	if (typeof eagle !== 'undefined') {
		collisionBlockEagle.x = eagle.x;
		collisionBlockEagle.y = eagle.y - eagle.height / 2 - collisionBlockEagle.height / 2;
	}
}, 5000);
// Initialize the foreground
var foreground1 = game.addChild(new Foreground());
foreground1.x = 2048 / 2;
foreground1.y = 2732 * 0.9;
var foreground2 = game.addChild(new Foreground());
foreground2.x = 2048 / 2 + foreground2.width;
foreground2.y = 2732 * 0.9;
var scoreTxt = new Text2('0', {
	size: 100,
	fill: "#ffffff"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Handle game updates
game.update = function () {
	coot.update();
	if (LK.ticks % 60 == 0) {
		score++;
		scoreTxt.setText(score);
	}
	// Check for collision between the Coot and the Collision Block
	if (coot.intersects(collisionBlockDuck) || coot.intersects(collisionBlockEagle)) {
		LK.showGameOver();
	}
	// Update the midgroundtrees
	midgroundtrees1.update();
	midgroundtrees2.update();
	// Update the water
	water1.update();
	water2.update();
	// Update the Duck obstacle
	duck.update();
	// Update the Eagle obstacle
	if (typeof eagle !== 'undefined') {
		eagle.update();
	}
	// Pin the collision block to the center of the duck
	if (currentObstacle instanceof Duck) {
		collisionBlockDuck.x = currentObstacle.x;
		collisionBlockDuck.y = currentObstacle.y;
	}
	// Pin the collision block to the center of the eagle
	if (typeof eagle !== 'undefined') {
		if (typeof eagle !== 'undefined') {
			collisionBlockEagle.x = eagle.x;
			collisionBlockEagle.y = eagle.y;
		}
	}
	// Update the foreground
	foreground1.update();
	foreground2.update();
};
// Handle touch events for jumping
game.down = function (x, y, obj) {
	if (typeof eagle !== 'undefined' && Math.abs(coot.x - eagle.x) < 500) {
		coot.dive();
	} else {
		coot.jump();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -267,10 +267,12 @@
 }
 initializeObstacle();
 // Attach a collision block on top of the duck
 var collisionBlockDuck = game.addChild(new CollisionBlock());
-collisionBlockDuck.x = currentObstacle.x;
-collisionBlockDuck.y = currentObstacle.y - currentObstacle.height / 2 - collisionBlockDuck.height / 2;
+if (currentObstacle) {
+	collisionBlockDuck.x = currentObstacle.x;
+	collisionBlockDuck.y = currentObstacle.y - currentObstacle.height / 2 - collisionBlockDuck.height / 2;
+}
 // Attach a collision block on top of the eagle
 var collisionBlockEagle = game.addChild(new CollisionBlock());
 LK.setTimeout(function () {
 	if (typeof eagle !== 'undefined') {