/**** 
* 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;
		// Special handling for first jump
		if (!game.gameStarted) {
			// Mark the bird as flying (no longer on wire) but don't enable gravity yet
			self.onWire = false;
			// Calculate target Y position (one power line above)
			var targetY = self.y - lineSpacing;
			// Calculate camera target for first jump (sync with bird movement)
			var cameraTarget = targetY - 2732 + 600; // Same formula as in updateCamera
			// First tween the camera smoothly
			tween(game, {
				cameraY: cameraTarget
			}, {
				duration: 500,
				easing: tween.easeOutQuad
			});
			// 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;
			// Store safe landing height to prevent immediate game over
			game.safeJumpHeight = targetY + 300; // More generous room for falling before game over
		} else {
			// For subsequent jumps
			if (self.onWire) {
				self.onWire = false; // Bird leaves wire
			}
			// 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) {
			// First, test if this is the first jump tween in progress
			var isTweening = false;
			if (tween.isActive && tween.isActive(self, 'y')) {
				isTweening = true;
			} else if (typeof tween.isTweening === 'function' && tween.isTweening(self, 'y')) {
				isTweening = true;
			}
			// Skip physics if being tweened during first jump
			if (isTweening) {
				// During tween, ensure we don't trigger game over
				self.flying = false; // Prevent falling physics
				return;
			}
			// Only apply gravity when bird is actually flying
			if (self.flying) {
				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;
			if (self.currentNest.y !== undefined) {
				self.y = self.currentNest.y - 30;
			}
		} else if (self.onWire) {
			// Safety check: if bird is somehow on wire but has no nest
			// Find closest nest or place in the center of screen
			// Don't immediately set flying to true to prevent immediate fall
			if (self.currentNest === null) {
				// Try to find the nearest nest
				var nearestNest = null;
				var minDistance = Infinity;
				for (var i = 0; i < nests.length; i++) {
					var distance = Math.abs(nests[i].x - self.x);
					if (distance < minDistance) {
						minDistance = distance;
						nearestNest = nests[i];
					}
				}
				if (nearestNest) {
					self.currentNest = nearestNest;
					nearestNest.occupied = true;
				} else {
					self.onWire = false;
					self.flying = true;
					self.velocity = 0;
				}
			}
		}
	};
	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;
	// Ensure at least one nest on the bottommost power line
	if (y === 2500) {
		nestCount = Math.max(nestCount, 2); // Guarantee at least two nests on bottom line for better gameplay
	}
	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++) {
		// If this is the bottom line, ensure at least one nest is near the center
		var nestX = y === 2500 && i === 0 ? 2048 / 2 // Center the first nest on bottom line
		: wallWidth + nestWidth / 2 + Math.random() * (availableWidth - nestWidth);
		nestPositions.push({
			x: nestX,
			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
	game.safeJumpHeight = null; // Will be set on first jump
	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();
		// Give time for nests to be created, then place bird
		LK.setTimeout(function () {
			// 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;
				bird.onWire = true;
				bottomNest.occupied = true;
			} else {
				// Ensure bird is properly placed on the bottommost power line if no nest was found
				var bottomLine = null;
				var maxY = -Infinity;
				for (var i = 0; i < powerLines.length; i++) {
					if (powerLines[i].initialY > maxY) {
						maxY = powerLines[i].initialY;
						bottomLine = powerLines[i];
					}
				}
				if (bottomLine) {
					// Create a nest on the bottom line
					var nest = new Nest();
					nest.x = 2048 / 2; // Center of screen
					nest.y = bottomLine.y - 5; // Slightly above the line
					nest.initialY = bottomLine.initialY - 5;
					game.addChild(nest);
					nests.push(nest);
					// Place bird on this nest
					bird.currentNest = nest;
					bird.x = nest.x;
					bird.y = nest.y - 30;
					bird.isJumpAllowed = true;
					bird.onWire = true;
					nest.occupied = 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');
		}, 100); // A bit more delay to ensure nests are created
	}, 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
			var birdBeingTweened = false;
			if (tween.isActive && tween.isActive(bird, 'y')) {
				birdBeingTweened = true;
			} else if (typeof tween.isTweening === 'function' && tween.isTweening(bird, 'y')) {
				birdBeingTweened = true;
			}
			if (birdBeingTweened) {
				// Move camera with smooth transition matching the bird's tween
				// For first jump, nearly instant camera positioning for better visual flow
				cameraY = cameraY * 0.1 + targetY * 0.9; // Almost direct camera movement to avoid viewport jump
			} 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() {
	// Don't check for game over if game hasn't started yet
	if (!game.gameStarted) return;
	// Prevent game over for first jump by checking if we're past the initial safe height
	// and add a grace period to allow the player to get used to controls
	var safeHeight = game.safeJumpHeight || cameraY + 3000;
	var graceModifier = game.gameStarted && LK.ticks < 180 ? 700 : 0; // Extended grace period right after game starts
	// Check if bird is actively being tweened (first jump animation)
	var birdBeingTweened = false;
	if (tween.isActive && tween.isActive(bird, 'y')) {
		birdBeingTweened = true;
	} else if (typeof tween.isTweening === 'function' && tween.isTweening(bird, 'y')) {
		birdBeingTweened = true;
	}
	// Check if camera is being tweened during first jump
	var cameraBeingTweened = false;
	if (tween.isActive && tween.isActive(game, 'cameraY')) {
		cameraBeingTweened = true;
	} else if (typeof tween.isTweening === 'function' && tween.isTweening(game, 'cameraY')) {
		cameraBeingTweened = true;
	}
	// Only trigger game over if:
	// 1. Bird is way too low (below camera view)
	// 2. Bird is past the safe height
	// 3. Bird is not in the first jump tween animation
	// 4. Camera is not being tweened during first jump
	if (!gameOver && !birdBeingTweened && !cameraBeingTweened && bird.y > cameraY + 3000 && (!game.safeJumpHeight || bird.y > safeHeight + graceModifier)) {
		gameOver = true;
		LK.getSound('fall').play();
		LK.showGameOver();
	}
}
// Main game loop
game.update = function () {
	if (gameOver) return;
	// Update bird if it exists
	if (bird) {
		// Double-check bird is defined before calling update
		if (typeof bird.update === 'function') {
			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 && typeof bird.jump === 'function') {
		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
@@ -28,8 +28,17 @@
 			// Mark the bird as flying (no longer on wire) but don't enable gravity yet
 			self.onWire = false;
 			// Calculate target Y position (one power line above)
 			var targetY = self.y - lineSpacing;
+			// Calculate camera target for first jump (sync with bird movement)
+			var cameraTarget = targetY - 2732 + 600; // Same formula as in updateCamera
+			// First tween the camera smoothly
+			tween(game, {
+				cameraY: cameraTarget
+			}, {
+				duration: 500,
+				easing: tween.easeOutQuad
+			});
 			// Use tween for smooth first jump
 			tween(self, {
 				y: targetY
 			}, {
@@ -469,10 +478,10 @@
 				birdBeingTweened = true;
 			}
 			if (birdBeingTweened) {
 				// Move camera with smooth transition matching the bird's tween
-				// Allow some delay in camera movement rather than instant positioning
-				cameraY = (cameraY * 1 + targetY) / 2; // Very smooth camera movement during tween
+				// For first jump, nearly instant camera positioning for better visual flow
+				cameraY = cameraY * 0.1 + targetY * 0.9; // Almost direct camera movement to avoid viewport jump
 			} else {
 				// Move camera to follow bird with smooth transition
 				cameraY = (cameraY * 4 + targetY) / 5; // Smoother camera movement
 			}
@@ -598,13 +607,21 @@
 		birdBeingTweened = true;
 	} else if (typeof tween.isTweening === 'function' && tween.isTweening(bird, 'y')) {
 		birdBeingTweened = true;
 	}
+	// Check if camera is being tweened during first jump
+	var cameraBeingTweened = false;
+	if (tween.isActive && tween.isActive(game, 'cameraY')) {
+		cameraBeingTweened = true;
+	} else if (typeof tween.isTweening === 'function' && tween.isTweening(game, 'cameraY')) {
+		cameraBeingTweened = true;
+	}
 	// Only trigger game over if:
 	// 1. Bird is way too low (below camera view)
 	// 2. Bird is past the safe height
 	// 3. Bird is not in the first jump tween animation
-	if (!gameOver && !birdBeingTweened && bird.y > cameraY + 3000 && (!game.safeJumpHeight || bird.y > safeHeight + graceModifier)) {
+	// 4. Camera is not being tweened during first jump
+	if (!gameOver && !birdBeingTweened && !cameraBeingTweened && bird.y > cameraY + 3000 && (!game.safeJumpHeight || bird.y > safeHeight + graceModifier)) {
 		gameOver = true;
 		LK.getSound('fall').play();
 		LK.showGameOver();
 	}