/**** 
* 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 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 Obstacle (Duck and Eagle combined)
var Obstacle = Container.expand(function (type) {
	var self = Container.call(this);
	var graphics;
	var type = Math.random() < 0.5 ? 'Duck' : 'Eagle';
	var collisionBlock = self.addChild(new CollisionBlock());
	collisionBlock.x = 0;
	collisionBlock.y = 0;
	graphics = self.attachAsset(type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speedX = -6;
	if (type === 'Eagle') {
		self.targetY = coot.y;
		self.speedY = (self.targetY - self.y) / 100;
	}
	self.update = function () {
		self.x += self.speedX;
		if (type === 'Eagle') {
			self.y += self.speedY;
			if (self.x <= -self.width / 2) {
				self.x = 2048 + self.width;
				self.y = -self.height / 2;
				self.targetY = coot.y;
				self.speedY = (self.targetY - self.y) / 100;
			}
			if (self.y < self.targetY) {
				self.speedY = (self.targetY - self.y) / 100;
			} else {
				self.speedY = 0;
			}
		} else if (type === 'Duck') {
			if (self.x <= -self.width / 2) {
				self.x = 2048 + self.width / 2; // Reset to the right side of the screen
			}
		}
		collisionBlock.x = 0;
		collisionBlock.y = 0;
	};
});
// 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
****/ 
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;
// 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 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
	if (!currentObstacle) {
		currentObstacle = game.addChild(new Obstacle());
		currentObstacle.x = 2048;
		currentObstacle.y = currentObstacle.children[1].type === 'Duck' ? 2732 * 0.75 : 2732 * 0.25; // Adjust Eagle's initial Y position
	} else {
		currentObstacle.update();
		if (currentObstacle.x < -currentObstacle.width / 2) {
			currentObstacle.destroy();
			currentObstacle = null;
			// Randomly decide the next obstacle type
			currentObstacle = game.addChild(new Obstacle());
			currentObstacle.x = 2048;
			currentObstacle.y = currentObstacle.children[1].type === 'Duck' ? 2732 * 0.75 : 2732 * 0.25; // Adjust Eagle's initial Y position
		}
	}
	// Update the foreground
	foreground1.update();
	foreground2.update();
};
// Handle touch events for jumping and diving
game.down = function (x, y, obj) {
	dragStartY = y; // Record the initial y position when touch starts
};
game.move = function (x, y, obj) {
	if (dragStartY !== null) {
		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
};

===================================================================
--- original.js
+++ change.js
@@ -120,8 +120,9 @@
 // Class for the Obstacle (Duck and Eagle combined)
 var Obstacle = Container.expand(function (type) {
 	var self = Container.call(this);
 	var graphics;
+	var type = Math.random() < 0.5 ? 'Duck' : 'Eagle';
 	var collisionBlock = self.addChild(new CollisionBlock());
 	collisionBlock.x = 0;
 	collisionBlock.y = 0;
 	graphics = self.attachAsset(type, {
@@ -269,22 +270,20 @@
 	water1.update();
 	water2.update();
 	// Update the current obstacle
 	if (!currentObstacle) {
-		var obstacleType = Math.random() < 0.5 ? 'Duck' : 'Eagle';
-		currentObstacle = game.addChild(new Obstacle(obstacleType));
+		currentObstacle = game.addChild(new Obstacle());
 		currentObstacle.x = 2048;
-		currentObstacle.y = obstacleType === 'Duck' ? 2732 * 0.75 : 2732 * 0.25; // Adjust Eagle's initial Y position
+		currentObstacle.y = currentObstacle.children[1].type === 'Duck' ? 2732 * 0.75 : 2732 * 0.25; // Adjust Eagle's initial Y position
 	} else {
 		currentObstacle.update();
 		if (currentObstacle.x < -currentObstacle.width / 2) {
 			currentObstacle.destroy();
 			currentObstacle = null;
 			// Randomly decide the next obstacle type
-			var nextObstacleType = Math.random() < 0.5 ? 'Duck' : 'Eagle';
-			currentObstacle = game.addChild(new Obstacle(nextObstacleType));
+			currentObstacle = game.addChild(new Obstacle());
 			currentObstacle.x = 2048;
-			currentObstacle.y = nextObstacleType === 'Duck' ? 2732 * 0.75 : 2732 * 0.25; // Adjust Eagle's initial Y position
+			currentObstacle.y = currentObstacle.children[1].type === 'Duck' ? 2732 * 0.75 : 2732 * 0.25; // Adjust Eagle's initial Y position
 		}
 	}
 	// Update the foreground
 	foreground1.update();