/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1");

/**** 
* Classes
****/ 
var Bird = Container.expand(function () {
	var self = Container.call(this);
	var birdGraphic = self.attachAsset('bird', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocity = 0;
	self.gravity = 0.5;
	self.jumpForce = -20;
	self.flying = false;
	self.onWire = true;
	self.currentNest = null;
	self.isJumpAllowed = true;
	self.jump = function () {
		// Only jump if allowed (when on a nest)
		if (!self.isJumpAllowed) return;
		if (self.onWire) {
			self.onWire = false;
		}
		// Special handling for first jump
		if (!game.gameStarted) {
			// Calculate target Y position (one power line above)
			var targetY = self.y - lineSpacing;
			// Use tween for smooth first jump
			tween(self, {
				y: targetY
			}, {
				duration: 500,
				easing: tween.easeOutQuad,
				onFinish: function onFinish() {
					// Re-enable bird physics after tween
					self.flying = true;
					self.velocity = 0; // Reset velocity after tween
				}
			});
			game.gameStarted = true;
			game.isFirstJump = false; // Already handled the first jump
		} else {
			// Normal jump physics for subsequent jumps
			self.velocity = self.jumpForce;
			self.flying = true;
		}
		// Disable jumping until landing on a nest again
		self.isJumpAllowed = false;
		// Create stars effect
		self.createStars();
		// Play flying sound
		LK.getSound('fly').play();
	};
	self.createStars = function () {
		for (var i = 0; i < 5; i++) {
			var star = LK.getAsset('star', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: self.x + (Math.random() * 60 - 30),
				y: self.y + (Math.random() * 60 - 30),
				alpha: 1
			});
			game.addChild(star);
			// Animate the star
			tween(star, {
				alpha: 0,
				scaleX: 0.2,
				scaleY: 0.2,
				x: star.x + (Math.random() * 40 - 20),
				y: star.y + (Math.random() * 40 - 20)
			}, {
				duration: 500,
				onFinish: function onFinish() {
					game.removeChild(star);
				}
			});
		}
	};
	self.update = function () {
		if (!self.onWire) {
			// Skip physics if being tweened during first jump
			if (tween.isActive && tween.isActive(self, 'y')) {
				return;
			}
			self.velocity += self.gravity;
			self.y += self.velocity;
			// Check if falling too fast
			if (self.velocity > 20) {
				self.velocity = 20;
			}
		} else if (self.currentNest) {
			// Bird follows the nest
			self.x = self.currentNest.x;
			self.y = self.currentNest.y - 30;
		}
	};
	self.down = function (x, y, obj) {
		self.jump();
	};
	return self;
});
var Nest = Container.expand(function () {
	var self = Container.call(this);
	var nestGraphic = self.attachAsset('nest', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.occupied = false;
	self.lastX = undefined;
	self.speed = 4; // Speed for horizontal movement
	self.direction = 1; // Direction for horizontal movement
	// Randomize initial direction
	self.randomizeDirection = function () {
		self.direction = Math.random() > 0.5 ? 1 : -1;
	};
	// Update method to handle movement and collisions
	self.update = function () {
		// Track last position for reference
		if (self.lastX === undefined) self.lastX = self.x;
		// Move nest horizontally
		self.x += self.speed * self.direction;
		// Check for wall collisions and reverse direction
		var wallWidth = 30; // Width of the wall assets
		var nestWidth = 100; // Width of nest
		if (self.x <= wallWidth + nestWidth / 2) {
			self.direction = 1; // Move right when hitting left wall
			self.x = wallWidth + nestWidth / 2;
		} else if (self.x >= 2048 - wallWidth - nestWidth / 2) {
			self.direction = -1; // Move left when hitting right wall
			self.x = 2048 - wallWidth - nestWidth / 2;
		}
		// Update last position
		self.lastX = self.x;
	};
	// Initialize random direction
	self.randomizeDirection();
	return self;
});
var PowerLine = Container.expand(function () {
	var self = Container.call(this);
	var lineGraphic = self.attachAsset('powerLine', {
		anchorX: 0,
		anchorY: 0.5
	});
	// Power lines are static - no update method needed
	return self;
});
var Star = Container.expand(function () {
	var self = Container.call(this);
	var starGraphic = self.attachAsset('star', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});

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

/**** 
* Game Code
****/ 
var score = 0;
var highScore = storage.highScore || 0;
var powerLines = [];
var nests = [];
var bird;
var cameraY = 0;
var gameOver = false;
var lineSpacing = 300;
var maxLines = 10;
var nextLineY = 2500;
var ascentCount = 0;
var lastNestLevel = null;
var removedBottomLines = 0;
// Initialize score display
var scoreTxt = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0, 0);
LK.gui.topRight.addChild(scoreTxt);
scoreTxt.x = -scoreTxt.width - 20;
scoreTxt.y = 20;
// Initialize high score display
var highScoreTxt = new Text2('Best: ' + highScore, {
	size: 40,
	fill: 0xFFFFFF
});
highScoreTxt.anchor.set(0, 0);
LK.gui.topRight.addChild(highScoreTxt);
highScoreTxt.x = -highScoreTxt.width - 20;
highScoreTxt.y = 100;
// Create background
var background = LK.getAsset('background', {
	anchorX: 0,
	anchorY: 0
});
game.addChild(background);
// Initialize bird
function initBird() {
	bird = new Bird();
	bird.x = 2048 / 2;
	bird.y = 2500;
	game.addChild(bird);
	// Bird will be positioned on a nest in initGame
}
// Create a power line with nests
function createPowerLine(y) {
	var powerLine = new PowerLine();
	powerLine.y = y;
	powerLine.initialY = y; // Store initial Y position
	// Set power line to span the whole width, respecting wall boundaries
	powerLine.x = 30; // Starting from left wall position
	game.addChild(powerLine);
	powerLines.push(powerLine);
	// Calculate nest properties once - more efficient
	var nestCount = Math.floor(Math.random() * 3) + 1;
	var nestWidth = 100;
	var wallWidth = 30; // Width of the wall assets
	var availableWidth = 2048 - nestWidth - wallWidth * 2; // Account for walls
	// Pre-calculate nest positions for better performance
	var nestPositions = [];
	for (var i = 0; i < nestCount; i++) {
		nestPositions.push({
			x: wallWidth + nestWidth / 2 + Math.random() * (availableWidth - nestWidth),
			y: y - 5
		});
	}
	// Add nests in a small timeout to prevent UI blocking
	LK.setTimeout(function () {
		// Place nests randomly along the power line
		for (var i = 0; i < nestCount; i++) {
			var nest = new Nest();
			// Random position along the power line
			nest.x = nestPositions[i].x;
			nest.y = nestPositions[i].y; // Slightly above the line
			nest.initialY = y - 5; // Store initial Y position
			game.addChild(nest);
			nests.push(nest);
		}
	}, 0); // Even a 0ms timeout helps by deferring to next event loop
	return powerLine;
}
// Initialize power lines
function initPowerLines() {
	// Clear existing lines and nests - optimize by checking length first
	if (powerLines.length > 0) {
		for (var i = 0; i < powerLines.length; i++) {
			game.removeChild(powerLines[i]);
		}
	}
	if (nests.length > 0) {
		for (var i = 0; i < nests.length; i++) {
			game.removeChild(nests[i]);
		}
	}
	powerLines = [];
	nests = [];
	// Create initial power lines - create in batches for better performance
	nextLineY = 2500;
	// Create lines in smaller batches to prevent blocking UI
	var linesBatch = 3;
	var currentLine = 0;
	function createLineBatch() {
		var batchEnd = Math.min(currentLine + linesBatch, maxLines);
		for (var i = currentLine; i < batchEnd; i++) {
			createPowerLine(nextLineY);
			nextLineY -= lineSpacing;
		}
		currentLine = batchEnd;
		if (currentLine < maxLines) {
			LK.setTimeout(createLineBatch, 1);
		}
	}
	createLineBatch();
}
// Initialize the game
function initGame() {
	score = 0;
	gameOver = false;
	game.gameStarted = false; // Flag to track if game has started (first jump)
	game.isFirstJump = false; // No longer needed as we use tween for first jump
	game.birdHighestPosition = null; // Track bird's highest (lowest y value) position
	ascentCount = 0;
	lastNestLevel = null;
	removedBottomLines = 0;
	updateScore(0);
	// Defer heavy initialization with a small timeout to allow the UI to render first
	LK.setTimeout(function () {
		initPowerLines();
		initBird();
		// Create walls at screen edges
		createWalls();
		// Find a nest on the bottommost line and place bird on it
		var bottomNest = null;
		var bottomY = 0;
		// First identify the bottommost line by finding the nest with largest Y value
		for (var i = 0; i < nests.length; i++) {
			if (nests[i].y > bottomY) {
				bottomY = nests[i].y;
				bottomNest = nests[i];
			}
		}
		// If we found a bottom nest, place bird on it
		if (bottomNest) {
			bird.currentNest = bottomNest;
			bird.x = bottomNest.x;
			bird.y = bottomNest.y - 30;
			bird.isJumpAllowed = true;
			bottomNest.occupied = true;
			bird.onWire = true;
		}
		// Initialize camera position to show bird at bottom of screen
		// Calculate camera position so bird is visible at screen bottom
		// Bird is at around y=2500, and we want it visible at the bottom of 2732 height screen
		cameraY = bird.y - 2732 + 200; // 200px from bottom
		// Play background music
		LK.playMusic('gameMusic');
	}, 50); // Short delay to let the UI render first
}
// Update score display
function updateScore(newScore) {
	score = newScore;
	scoreTxt.setText('Score: ' + score);
	if (score > highScore) {
		highScore = score;
		storage.highScore = highScore;
		highScoreTxt.setText('Best: ' + highScore);
	}
}
// Check if bird is on a nest
function checkNestCollision() {
	if (bird.velocity > 0) {
		// Only check when bird is falling
		for (var i = 0; i < nests.length; i++) {
			var nest = nests[i];
			if (!nest.occupied && bird.intersects(nest)) {
				bird.velocity = 0;
				bird.onWire = true;
				bird.currentNest = nest;
				nest.occupied = true;
				// Re-enable jumping now that bird has landed
				bird.isJumpAllowed = true;
				// Update score based on height
				var newScore = Math.floor((2732 - nest.y) / 100);
				updateScore(newScore);
				// Check for successful ascent to a higher wire
				var currentLevel = Math.floor(nest.initialY / lineSpacing);
				if (lastNestLevel !== null && currentLevel < lastNestLevel) {
					ascentCount++;
					// Every 3 successful ascents, remove the bottommost wire
					if (ascentCount % 3 === 0) {
						removeBottomWire();
					}
				}
				lastNestLevel = currentLevel;
				// Play landing sound
				LK.getSound('land').play();
				return true;
			}
		}
	}
	return false;
}
// Move camera based on bird position and directly tied to the bird's upward progress
function updateCamera() {
	// Track the bird's highest position (lowest y value)
	if (!game.birdHighestPosition || bird.y < game.birdHighestPosition) {
		game.birdHighestPosition = bird.y;
		// When bird moves upward, camera should follow
		// Calculate target camera position to keep bird visible in the lower part of screen
		var targetY = bird.y - 2732 + 600; // Keep bird 600px from bottom of screen when jumping up
		// Only move camera up (not down) when bird makes upward progress
		if (targetY < cameraY) {
			// If bird is being tweened (first jump), sync camera with bird movement
			if (tween.isActive && tween.isActive(bird, 'y')) {
				// Move camera with smooth transition matching the bird's tween
				cameraY = targetY;
			} else {
				// Move camera to follow bird with smooth transition
				cameraY = (cameraY * 4 + targetY) / 5; // Smoother camera movement
			}
		}
	}
	// Only apply camera transformation after gameplay begins (after first jump)
	// This keeps wires stationary at their initial positions
	if (game.gameStarted) {
		// Apply camera transformation to game objects
		var offsetY = cameraY;
		for (var i = 0; i < powerLines.length; i++) {
			powerLines[i].y = powerLines[i].initialY - offsetY + 2732;
		}
		for (var i = 0; i < nests.length; i++) {
			nests[i].y = nests[i].initialY - offsetY + 2732;
		}
		// Update wall positions if they exist
		var walls = game.children.filter(function (child) {
			return child.isAsset && child.isAsset('wall');
		});
		for (var i = 0; i < walls.length; i++) {
			walls[i].y = walls[i].initialY - offsetY + 2732;
		}
	}
	// Bird follows camera movement when on wire
	if (bird.onWire && bird.currentNest) {
		bird.y = bird.currentNest.y - 30;
	}
}
// Generate new lines if needed
function checkGenerateLines() {
	if (nextLineY > cameraY - 2732) {
		createPowerLine(nextLineY);
		nextLineY -= lineSpacing;
	}
}
// Create walls at screen edges
function createWalls() {
	// Prepare wall properties before asset loading
	var wallProps = {
		anchorX: 0,
		anchorY: 0
	};
	// Using setTimeout to create a small delay before accessing assets
	LK.setTimeout(function () {
		var leftWall = LK.getAsset('wall', {
			anchorX: 0,
			anchorY: 0
		});
		leftWall.x = 0;
		leftWall.y = 0;
		leftWall.initialY = 0; // Store initial Y position
		game.addChild(leftWall);
		var rightWall = LK.getAsset('wall', {
			anchorX: 0,
			anchorY: 0
		});
		rightWall.x = 2048 - rightWall.width;
		rightWall.y = 0;
		rightWall.initialY = 0; // Store initial Y position
		game.addChild(rightWall);
	}, 5); // Small delay to prevent blocking UI
}
// Function to remove the bottommost wire and its nests
function removeBottomWire() {
	// Find the bottommost wire (highest y value)
	var bottomLineIndex = -1;
	var bottomY = -Infinity;
	for (var i = 0; i < powerLines.length; i++) {
		if (powerLines[i].initialY > bottomY) {
			bottomY = powerLines[i].initialY;
			bottomLineIndex = i;
		}
	}
	if (bottomLineIndex >= 0) {
		// Remove the wire
		game.removeChild(powerLines[bottomLineIndex]);
		var removedLine = powerLines.splice(bottomLineIndex, 1)[0];
		// Remove all nests on this wire
		for (var i = nests.length - 1; i >= 0; i--) {
			// Check if the nest is on the removed wire (approximately same initialY)
			if (Math.abs(nests[i].initialY - (removedLine.initialY - 5)) < 10) {
				// If bird is on this nest, it will fall
				if (bird.currentNest === nests[i]) {
					bird.currentNest = null;
					bird.onWire = false;
					bird.isJumpAllowed = false;
					bird.velocity = 1; // Start falling
				}
				game.removeChild(nests[i]);
				nests.splice(i, 1);
			}
		}
		removedBottomLines++;
	}
}
// Remove off-screen power lines and nests
function cleanupObjects() {
	for (var i = powerLines.length - 1; i >= 0; i--) {
		if (powerLines[i].y > cameraY + 3000) {
			game.removeChild(powerLines[i]);
			powerLines.splice(i, 1);
		}
	}
	for (var i = nests.length - 1; i >= 0; i--) {
		if (nests[i].y > cameraY + 3000) {
			game.removeChild(nests[i]);
			nests.splice(i, 1);
		}
	}
}
// Handle game over
function handleGameOver() {
	if (!gameOver && bird.y > cameraY + 3000) {
		gameOver = true;
		LK.getSound('fall').play();
		LK.showGameOver();
	}
}
// Main game loop
game.update = function () {
	if (gameOver) return;
	// Update bird if it exists
	if (bird) {
		bird.update();
	}
	// Power lines are static, no need to update them
	// Update nests
	for (var i = 0; i < nests.length; i++) {
		nests[i].update();
	}
	// Check if bird landed on a nest and bird exists
	if (bird) {
		checkNestCollision();
		// Update camera position
		updateCamera();
	}
	// Generate new lines if needed
	checkGenerateLines();
	// Remove off-screen objects
	cleanupObjects();
	// Check game over condition
	if (bird) {
		handleGameOver();
	}
};
// Bird jump on screen tap/click
game.down = function (x, y, obj) {
	if (!gameOver) {
		bird.jump();
	}
};
// Show loading indicator
var loadingText = new Text2('Loading...', {
	size: 80,
	fill: 0xFFFFFF
});
loadingText.anchor.set(0.5, 0.5);
loadingText.x = 2048 / 2;
loadingText.y = 2732 / 2;
game.addChild(loadingText);
// Create a preloader to load game assets efficiently
function startGameWithPreloader() {
	// Use tween to animate loading text while assets are prepared
	tween(loadingText, {
		alpha: 0.5
	}, {
		duration: 500,
		easing: tween.easeInOutQuad,
		loop: true,
		yoyo: true
	});
	// Defer game initialization to prevent startup lag
	LK.setTimeout(function () {
		// Remove loading indicator
		tween(loadingText, {
			alpha: 0
		}, {
			duration: 300,
			onFinish: function onFinish() {
				game.removeChild(loadingText);
				// Initialize game
				initGame();
			}
		});
	}, 200); // Give enough time for engine to initialize
}
// Start game with preloader
startGameWithPreloader();

===================================================================
--- original.js
+++ change.js
@@ -411,9 +411,9 @@
 			walls[i].y = walls[i].initialY - offsetY + 2732;
 		}
 	}
 	// Bird follows camera movement when on wire
-	if (bird.onWire) {
+	if (bird.onWire && bird.currentNest) {
 		bird.y = bird.currentNest.y - 30;
 	}
 }
 // Generate new lines if needed