/**** 
* Classes
****/
var BuffIndicator = Container.expand(function (buffType) {
	var self = Container.call(this);
	var indicatorGraphics;
	switch (buffType) {
		case 'invincibility':
			indicatorGraphics = self.attachAsset('star', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			break;
		case 'multiplier':
			indicatorGraphics = self.attachAsset('diamond', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			break;
		case 'flight':
			indicatorGraphics = self.attachAsset('wings', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			break;
	}
	self.alpha = 0.5; // Make the indicator semi-transparent
	self.lifetime = 5000; // The duration for which the indicator is displayed
	self.update = function () {
		self.lifetime -= LK.tickDuration;
		if (self.lifetime <= 0) {
			self.destroy();
		}
	};
});
var Bird = Container.expand(function () {
	var self = Container.call(this);
	var birdGraphics = self.attachAsset('bird', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityY = 0;
	self.gravity = 0.6;
	self.invincible = false;
	self.scoreMultiplier = 1;
	self.flapPower = -15;
	self.flap = function () {
		self.velocityY = self.flapPower;
		self.tweenUp = true;
		self.tweenUpTime = 0;
	};
	self.updatePhysics = function () {
		if (self.aiControlled) {
			self.aiNavigate();
		} else {
			if (self.tweenUp) {
				self.tweenUpTime += 1;
				if (self.tweenUpTime > 10) {
					self.tweenUp = false;
					self.tweenUpTime = 0;
				}
			} else {
				self.velocityY += self.gravity;
			}
			self.y += self.velocityY;
		}
		// Update bird's rotation based on velocity
		self.rotation = Math.max(Math.min(self.velocityY * 0.02, Math.PI / 2), -Math.PI / 2);
		// Lock the bird's horizontal position to the center of the screen
		self.x = game.width / 2;
		// Keep the bird within the game boundaries and check for ground collision
		if (self.y > game.height - ground.height) {
			self.y = game.height - ground.height;
			// Create particle effect for collision with ground
			LK.effects.flashObject(self, 0xff0000, 700);
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
		} else if (self.y < 0) {
			self.y = 0;
		}
	};
	self.aiNavigate = function () {
		// AI logic to navigate through pipes
		var closestObstacle = self.aiObstacles.reduce(function (closest, obstacle) {
			var distance = obstacle.x - self.x;
			if (closest === null || distance < closest.distance) {
				return {
					obstacle: obstacle,
					distance: distance
				};
			}
			return closest;
		}, null);
		if (closestObstacle && closestObstacle.distance < 300) {
			var gapCenter = (closestObstacle.obstacle.getTopPipe().y + closestObstacle.obstacle.getBottomPipe().y) / 2;
			if (self.y < gapCenter - 30) {
				self.velocityY = 3;
			} else if (self.y > gapCenter + 30) {
				self.velocityY = -3;
			} else {
				self.velocityY = 0;
			}
		}
		self.y += self.velocityY;
	};
});
var MainMenu = Container.expand(function () {
	var self = Container.call(this);
	self.menuItems = [];
	self.createMenuItem = function (text, levelIndex) {
		var menuItem = new Text2(text, {
			size: 100,
			fill: '#ffffff'
		});
		menuItem.levelIndex = levelIndex;
		menuItem.y = game.height / 2 - self.menuItems.length * 200 / 2 + levelIndex * 200;
		menuItem.anchor.set(0.5, 0.5);
		menuItem.x = game.width / 2;
		menuItem.on('down', function (obj) {
			if (levelManager.getLevelDesign(levelIndex)) {
				// Generate a unique randomized map and pipe layout
				var pipePositions = levelManager.generateRandomPipes(levelIndex);
				// Start the game with the generated pipe positions
				startGame(levelIndex, pipePositions);
			} else {
				// Level is locked
				// Placeholder for level locked feedback
			}
		});
		self.addChild(menuItem);
		var button = new Button('Start', function () {
			// Start the game or level here
			// Placeholder for the correct game start function
		});
		button.x = menuItem.x + menuItem.width / 2 + 50; // Position button to the right of the menu item
		button.y = menuItem.y;
		self.addChild(button);
		self.menuItems.push({
			menuItem: menuItem,
			button: button
		});
	};
	self.createMenuItem('Level 1', 0);
	self.createMenuItem('Level 2', 1);
	self.createMenuItem('Level 3', 2);
});
var MovingObstacle = Container.expand(function () {
	var self = Container.call(this);
	var topPipe = self.attachAsset('largePipe', {
		anchorX: 0.5,
		anchorY: 1,
		flipY: 1 // Flip the top pipe vertically
	});
	var bottomPipe = self.attachAsset('largePipe', {
		anchorX: 0.5,
		anchorY: 0
	});
	var gapSize = 300;
	self.verticalSpeed = 2;
	self.direction = 1;
	self.setGap = function (gapY) {
		topPipe.y = gapY - gapSize / 2 - topPipe.height;
		bottomPipe.y = gapY + gapSize / 2;
	};
	self.move = function () {
		self.x -= 4; // Move left
		if (self.y <= 0 || self.y >= game.height - bottomPipe.height - gapSize) {
			self.direction *= -1; // Change direction when hitting bounds
		}
		self.y += self.verticalSpeed * self.direction; // Move vertically
	};
	self.resetPosition = function (newX, newY) {
		self.x = newX;
		self.y = newY;
	};
	self.getTopPipe = function () {
		return topPipe;
	};
	self.getBottomPipe = function () {
		return bottomPipe;
	};
});
var Button = Container.expand(function (label, callback) {
	var self = Container.call(this);
	var buttonGraphics = self.attachAsset('ground', {
		width: 100,
		height: 50,
		color: 0x0000ff,
		shape: 'box'
	});
	var buttonText = new Text2(label, {
		size: 50,
		fill: '#ffffff'
	});
	buttonText.anchor.set(0.5, 0.5);
	buttonText.x = buttonGraphics.width / 2;
	buttonText.y = buttonGraphics.height / 2;
	self.addChild(buttonText);
	self.interactive = true;
	self.buttonMode = true;
	self.on('down', function (obj) {
		callback();
	});
});
var AIWings = Container.expand(function () {
	var self = Container.call(this);
	var wingsGraphics = self.attachAsset('wings', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.activateAI = function (bird, obstacles) {
		bird.aiControlled = true;
		bird.aiObstacles = obstacles;
		LK.setTimeout(function () {
			bird.aiControlled = false;
			bird.aiObstacles = null;
		}, 5000);
	};
	self.move = function () {
		self.x -= 4;
	};
	self.collect = function (bird) {
		self.activateAI(bird, game.children.filter(function (child) {
			return child instanceof MovingObstacle;
		}));
		// Create a visual indicator for the active AI power-up
		var buffIndicator = new BuffIndicator('flight');
		buffIndicator.x = bird.x;
		buffIndicator.y = bird.y - bird.height;
		game.addChild(buffIndicator);
		self.destroy();
	};
});
var LevelManager = Container.expand(function () {
	var self = Container.call(this);
	LevelManager.prototype.generateRandomPipes = function (levelIndex) {
		var level = this.levels[levelIndex];
		var pipePositions = [];
		for (var i = 0; i < level.pipes.length; i++) {
			// Randomize pipe position within a range
			pipePositions.push(Math.random() * (game.height - 200) + 100);
		}
		return pipePositions;
	};
	self.levels = [{
		pipes: [300, 500, 700],
		unlocked: true
	}, {
		pipes: [250, 450, 650, 850],
		unlocked: false
	}, {
		pipes: [200, 400, 600, 800, 1000],
		unlocked: false
	}];
	self.unlockLevel = function (levelIndex) {
		if (levelIndex < self.levels.length) {
			self.levels[levelIndex].unlocked = true;
		}
	};
	self.getLevelDesign = function (levelIndex) {
		if (levelIndex < self.levels.length && self.levels[levelIndex].unlocked) {
			return self.levels[levelIndex].pipes;
		}
		return null;
	};
});

/**** 
* Initialize Game
****/
var game = new LK.Game({
	backgroundColor: 0x87CEEB // Init game with sky blue background
});

/**** 
* Game Code
****/
// Initialize ground asset
var ground = game.addChild(LK.getAsset('ground', {
	anchorX: 0.0,
	// Left anchor x-coordinate
	anchorY: 1.0,
	// Bottom anchor y-coordinate
	x: 0,
	// Position x-coordinate
	y: game.height // Position y-coordinate
}));
function startGame(levelIndex, pipePositions) {
	var powerUps = [];
	// Clear the main menu
	if (mainMenu) {
		mainMenu.destroy();
		mainMenu = null;
	}
	// Create and initialize the bird
	var bird = game.addChild(new Bird());
	bird.x = game.width / 2;
	bird.y = game.height / 2;
	var obstacles = [];
	// Create and position pipes according to the generated positions
	// Add touch event to make the bird flap and jump
	game.on('down', function (obj) {
		// Ensure bird is defined and accessible
		if (bird) {
			bird.flap();
		}
		// Update bird's position immediately after flapping
		bird.updatePhysics();
	});
	// Set up the game tick event for the level
	var pipeCreationInterval = 1500; // Time in milliseconds between pipe creation
	var lastPipeCreationTime = Date.now();
	LK.on('tick', function () {
		// Update bird physics
		bird.updatePhysics();
		// Move obstacles and create new ones at intervals
		if (obstacles) {
			for (var i = obstacles.length - 1; i >= 0; i--) {
				obstacles[i].move();
				// Remove off-screen obstacles
				if (obstacles[i].x < -obstacles[i].width) {
					obstacles[i].destroy();
					obstacles.splice(i, 1);
				}
			}
			// Check if it's time to create a new pipe
			if (Date.now() - lastPipeCreationTime > pipeCreationInterval) {
				var obstacle = game.addChild(new MovingObstacle());
				obstacle.setGap(Math.random() * (game.height - 200) + 100);
				obstacle.x = game.width;
				obstacles.push(obstacle);
				lastPipeCreationTime = Date.now();
			}
		}
		// Generate power-ups at intervals
		if (LK.ticks % 600 == 0) {
			var powerUpType = ['invincibility', 'multiplier', 'flight'][Math.floor(Math.random() * 3)];
			var powerUp = new PowerUp(powerUpType);
			powerUp.x = game.width;
			powerUp.y = Math.random() * (game.height - 200) + 100;
			game.addChild(powerUp);
			powerUps.push(powerUp);
		}
		// Move power-ups and check for collection
		for (var p = powerUps.length - 1; p >= 0; p--) {
			powerUps[p].move();
			if (bird.intersects(powerUps[p])) {
				powerUps[p].collect(bird);
				powerUps.splice(p, 1);
			} else if (powerUps[p].x < -powerUps[p].width) {
				powerUps[p].destroy();
				powerUps.splice(p, 1);
			}
		}
		// Check for collision between the bird and the pipes and increment score
		var passedPipe = false;
		for (var i = 0; i < obstacles.length; i++) {
			var obstacle = obstacles[i];
			var topPipe = obstacle.getTopPipe();
			var bottomPipe = obstacle.getBottomPipe();
			if (bird.intersects(topPipe) || bird.intersects(bottomPipe)) {
				// Create particle effect for collision with pipe
				// The correct function to create particles is not provided in the LK engine documentation.
				// Assuming there is a function like LK.createParticles, the following code should be used:
				LK.effects.flashObject(bird, 0xff0000, 700);
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
				break;
			} else if (bird.x > topPipe.x + topPipe.width && !obstacle.passed) {
				obstacle.passed = true;
				passedPipe = true;
			}
		}
		if (passedPipe) {
			LK.setScore(LK.getScore() + 1 * bird.scoreMultiplier);
			scoreTxt.setText(LK.getScore());
			// Create particle effect for scoring
			LK.effects.flashObject(bird, 0xffff00, 500);
		}
	});
}
var powerUps = [];
var mainMenu;
var bird = null;
var levelManager = game.addChild(new LevelManager());
mainMenu = game.addChild(new MainMenu());
var scoreTxt = new Text2('0', {
	size: 150,
	fill: "#ffffff",
	anchorX: 0.5,
	anchorY: 0
});
LK.gui.top.addChild(scoreTxt);
startGame(0, levelManager.generateRandomPipes(0));

===================================================================
--- original.js
+++ change.js
@@ -49,18 +49,22 @@
 		self.tweenUp = true;
 		self.tweenUpTime = 0;
 	};
 	self.updatePhysics = function () {
-		if (self.tweenUp) {
-			self.tweenUpTime += 1;
-			if (self.tweenUpTime > 10) {
-				self.tweenUp = false;
-				self.tweenUpTime = 0;
-			}
+		if (self.aiControlled) {
+			self.aiNavigate();
 		} else {
-			self.velocityY += self.gravity;
+			if (self.tweenUp) {
+				self.tweenUpTime += 1;
+				if (self.tweenUpTime > 10) {
+					self.tweenUp = false;
+					self.tweenUpTime = 0;
+				}
+			} else {
+				self.velocityY += self.gravity;
+			}
+			self.y += self.velocityY;
 		}
-		self.y += self.velocityY;
 		// Update bird's rotation based on velocity
 		self.rotation = Math.max(Math.min(self.velocityY * 0.02, Math.PI / 2), -Math.PI / 2);
 		// Lock the bird's horizontal position to the center of the screen
 		self.x = game.width / 2;
@@ -74,8 +78,32 @@
 		} else if (self.y < 0) {
 			self.y = 0;
 		}
 	};
+	self.aiNavigate = function () {
+		// AI logic to navigate through pipes
+		var closestObstacle = self.aiObstacles.reduce(function (closest, obstacle) {
+			var distance = obstacle.x - self.x;
+			if (closest === null || distance < closest.distance) {
+				return {
+					obstacle: obstacle,
+					distance: distance
+				};
+			}
+			return closest;
+		}, null);
+		if (closestObstacle && closestObstacle.distance < 300) {
+			var gapCenter = (closestObstacle.obstacle.getTopPipe().y + closestObstacle.obstacle.getBottomPipe().y) / 2;
+			if (self.y < gapCenter - 30) {
+				self.velocityY = 3;
+			} else if (self.y > gapCenter + 30) {
+				self.velocityY = -3;
+			} else {
+				self.velocityY = 0;
+			}
+		}
+		self.y += self.velocityY;
+	};
 });
 var MainMenu = Container.expand(function () {
 	var self = Container.call(this);
 	self.menuItems = [];
@@ -173,57 +201,31 @@
 	self.on('down', function (obj) {
 		callback();
 	});
 });
-var PowerUp = Container.expand(function (type) {
+var AIWings = Container.expand(function () {
 	var self = Container.call(this);
-	var powerUpGraphics;
-	switch (type) {
-		case 'invincibility':
-			powerUpGraphics = self.attachAsset('star', {
-				anchorX: 0.5,
-				anchorY: 0.5
-			});
-			self.effect = function (bird) {
-				bird.invincible = true;
-				LK.setTimeout(function () {
-					bird.invincible = false;
-				}, 5000);
-			};
-			break;
-		case 'multiplier':
-			powerUpGraphics = self.attachAsset('diamond', {
-				anchorX: 0.5,
-				anchorY: 0.5
-			});
-			self.effect = function (bird) {
-				bird.scoreMultiplier = 2;
-				LK.setTimeout(function () {
-					bird.scoreMultiplier = 1;
-				}, 5000);
-			};
-			break;
-		case 'flight':
-			powerUpGraphics = self.attachAsset('wings', {
-				anchorX: 0.5,
-				anchorY: 0.5
-			});
-			self.effect = function (bird) {
-				bird.gravity = 0;
-				bird.velocityY = 0;
-				LK.setTimeout(function () {
-					bird.gravity = 0.6;
-				}, 5000);
-			};
-			break;
-	}
+	var wingsGraphics = self.attachAsset('wings', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.activateAI = function (bird, obstacles) {
+		bird.aiControlled = true;
+		bird.aiObstacles = obstacles;
+		LK.setTimeout(function () {
+			bird.aiControlled = false;
+			bird.aiObstacles = null;
+		}, 5000);
+	};
 	self.move = function () {
 		self.x -= 4;
 	};
 	self.collect = function (bird) {
-		self.effect(bird);
-		// Create a visual indicator for the active power-up
-		var buffIndicator = new BuffIndicator(type);
+		self.activateAI(bird, game.children.filter(function (child) {
+			return child instanceof MovingObstacle;
+		}));
+		// Create a visual indicator for the active AI power-up
+		var buffIndicator = new BuffIndicator('flight');
 		buffIndicator.x = bird.x;
 		buffIndicator.y = bird.y - bird.height;
 		game.addChild(buffIndicator);
 		self.destroy();