/**** 
* Classes
****/ 
// Boss class (for 2nd area end boss)
var Boss = Container.expand(function () {
	var self = Container.call(this);
	// Use the new unique boss image asset for the boss look
	var bossAsset = self.attachAsset('bossUnique', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = bossAsset.width;
	self.height = bossAsset.height;
	self.vx = -2; // Slow horizontal movement (optional)
	self.vy = 0;
	self.lastX = 0;
	self.lastY = 0;
	self.lastWasIntersecting = false;
	self.hp = 10; // Boss hit points
	self.isBoss = true;
	// Boss fight state
	self.phase = 1; // 1: normal, 2: jump, 3: fast
	self.attackTimer = 0;
	self.attackCooldown = 180; // frames between attacks (3 seconds at 60fps)
	// Boss only starts firing after player reaches boss platform
	self.bossStartFiring = false;
	self.jumpTimer = 0;
	self.isJumping = false;
	self.jumpVy = 0;
	self.groundY = self.y; // y position where boss stands
	self.shieldActive = false;
	self.shieldTimer = 0;
	self.shieldDuration = 60; // frames
	self.weakSpotOpen = false;
	self.weakSpotTimer = 0;
	self.weakSpotDuration = 40; // frames
	self.lastPhase = 1;
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		// --- Boss Phase Logic ---
		// Phase changes based on HP
		if (self.hp <= 6 && self.phase === 1) {
			self.phase = 2; // Start jumping attacks
			self.attackCooldown = 180; // 3 seconds at 60fps
		}
		if (self.hp <= 3 && self.phase === 2) {
			self.phase = 3; // Faster, more aggressive
			self.attackCooldown = 180; // 3 seconds at 60fps
		}
		// --- Boss Shield (defense) ---
		if (!self.shieldActive && Math.random() < 0.008 && self.phase > 1) {
			self.shieldActive = true;
			self.shieldTimer = self.shieldDuration;
			// Optional: visual effect for shield (tint blue)
			if (self.displayObject) {
				self.displayObject.tint = 0x44aaff;
			}
		}
		if (self.shieldActive) {
			self.shieldTimer--;
			if (self.shieldTimer <= 0) {
				self.shieldActive = false;
				if (self.displayObject) {
					self.displayObject.tint = 0xffffff;
				}
			}
		}
		// --- Weak Spot (vulnerable) ---
		if (!self.weakSpotOpen && Math.random() < 0.01 && self.phase > 1 && !self.shieldActive) {
			self.weakSpotOpen = true;
			self.weakSpotTimer = self.weakSpotDuration;
			// Optional: visual effect for weak spot (tint yellow)
			if (self.displayObject) {
				self.displayObject.tint = 0xffee44;
			}
		}
		if (self.weakSpotOpen) {
			self.weakSpotTimer--;
			if (self.weakSpotTimer <= 0) {
				self.weakSpotOpen = false;
				if (self.displayObject) {
					self.displayObject.tint = 0xffffff;
				}
			}
		}
		// --- Boss Attacks ---
		if (self.bossStartFiring) {
			self.attackTimer++;
			if (self.attackTimer >= self.attackCooldown && !self.shieldActive && !self.isJumping && !self.isLeaping) {
				self.attackTimer = 0;
				// Choose attack: 50% chance to leap, 50% to fire
				var doLeap = false;
				if (self.phase >= 2 && Math.random() < 0.5) {
					doLeap = true;
				}
				if (doLeap) {
					// Start leap attack: jump toward player, then return
					self.isLeaping = true;
					self.leapPhase = 0; // 0: going to player, 1: returning
					self.leapStartX = self.x;
					self.leapStartY = self.y;
					// Target player position at leap start
					self.leapTargetX = typeof player !== "undefined" ? player.x : self.x;
					self.leapTargetY = self.groundY;
					// Calculate leap velocity to reach player in N frames
					var leapFrames = 24;
					self.leapTimer = 0;
					self.leapTotalFrames = leapFrames;
					self.leapVX = (self.leapTargetX - self.x) / leapFrames;
					self.leapVY = -44; // Upward velocity
					self.leapGravity = (self.groundY - self.y - self.leapVY * leapFrames) * 2 / (leapFrames * leapFrames);
				} else {
					// Boss always fires projectile at player every attack, regardless of phase
					if (typeof bossFireProjectile === "function") {
						bossFireProjectile(self, self.phase === 3);
					}
				}
			}
		}
		// --- Boss Leap Attack ---
		if (self.isLeaping) {
			// Leap phase 0: jump toward player
			if (self.leapPhase === 0) {
				self.x += self.leapVX;
				self.y += self.leapVY;
				self.leapVY += self.leapGravity;
				self.leapTimer++;
				// If reached or passed groundY, land and start return
				if (self.y >= self.groundY) {
					self.y = self.groundY;
					self.leapPhase = 1;
					// On landing, create shockwave (damage if player is close)
					if (typeof bossShockwave === "function") {
						bossShockwave(self);
					}
					// Prepare return leap
					var returnFrames = 24;
					self.leapTimer = 0;
					self.leapTotalFrames = returnFrames;
					self.leapVX = (self.leapStartX - self.x) / returnFrames;
					self.leapVY = -38; // Upward velocity for return
					self.leapGravity = (self.groundY - self.y - self.leapVY * returnFrames) * 2 / (returnFrames * returnFrames);
				}
			} else if (self.leapPhase === 1) {
				// Return leap to original position
				self.x += self.leapVX;
				self.y += self.leapVY;
				self.leapVY += self.leapGravity;
				self.leapTimer++;
				if (self.y >= self.groundY || self.leapTimer >= self.leapTotalFrames) {
					self.y = self.groundY;
					self.x = self.leapStartX;
					self.isLeaping = false;
					self.leapPhase = 0;
					// On landing, create shockwave (damage if player is close)
					if (typeof bossShockwave === "function") {
						bossShockwave(self);
					}
				}
			}
		}
		// --- Boss Jumping (old jump attack, only used if not leaping) ---
		if (self.isJumping) {
			self.y += self.jumpVy;
			self.jumpVy += 4.5; // gravity
			if (self.y >= self.groundY) {
				self.y = self.groundY;
				self.isJumping = false;
				// On landing, create shockwave (damage if player is close)
				if (typeof bossShockwave === "function") {
					bossShockwave(self);
				}
			}
		}
		// --- Boss Movement (side to side in phase 3) ---
		if (self.phase === 3 && !self.isJumping && !self.isLeaping) {
			// Move left and right slowly
			if (!self.moveDir) {
				self.moveDir = -1;
			}
			self.x += self.moveDir * 7;
			// Clamp to wide platform area (assume platform at y = self.groundY + boss.height/2 + 200)
			var minX = self.x0 || self.x - 600;
			var maxX = self.x1 || self.x + 600;
			if (!self.x0) {
				self.x0 = self.x - 600;
			}
			if (!self.x1) {
				self.x1 = self.x + 600;
			}
			if (self.x < minX) {
				self.x = minX;
				self.moveDir = 1;
			}
			if (self.x > maxX) {
				self.x = maxX;
				self.moveDir = -1;
			}
		}
	};
	return self;
});
// BossBullet class: used for boss projectiles, uses bossBullet asset
var BossBullet = Container.expand(function () {
	var self = Container.call(this);
	var bossBulletAsset = self.attachAsset('bossBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = bossBulletAsset.width;
	self.height = bossBulletAsset.height;
	self.vx = 0;
	self.vy = 0;
	self.lastX = 0;
	self.lastY = 0;
	self.isBossProjectile = true;
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		self.x += self.vx;
		self.y += self.vy;
		// Clamp boss projectiles within boss platform bounds
		if (typeof platforms !== "undefined" && platforms.length > 0) {
			// Find the boss platform (the widest one, used for boss)
			var bossPlat = null;
			for (var i = 0; i < platforms.length; i++) {
				if (platforms[i].width >= 1800) {
					bossPlat = platforms[i];
					break;
				}
			}
			if (bossPlat) {
				var minX = bossPlat.x;
				var maxX = bossPlat.x + bossPlat.width;
				// Clamp self.x to platform bounds
				if (self.x < minX) {
					self.x = minX;
				}
				if (self.x > maxX) {
					self.x = maxX;
				}
			}
		}
	};
	return self;
});
// Bullet class
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	// Use the new bullet figure asset
	var bulletAsset = self.attachAsset('bulletFigure', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = bulletAsset.width;
	self.height = bulletAsset.height;
	self.vx = 40; // Bullet speed (right)
	self.vy = 0; // Add vy for vertical movement
	self.active = true;
	self.lastX = 0;
	self.lastY = 0;
	self.isControlled = false; // If true, player can control direction
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		// If controlled, vx/vy may be set by player, else keep moving
		self.x += self.vx;
		self.y += self.vy;
	};
	return self;
});
// Coin class
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinAsset = self.attachAsset('coinCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = coinAsset.width;
	self.height = coinAsset.height;
	return self;
});
// Enemy class: flies from right to left, tries to hit the player
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyAsset = self.attachAsset('hazard', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = enemyAsset.width;
	self.height = enemyAsset.height;
	self.vx = -8 - Math.random() * 4; // Move left, much slower speed
	self.lastX = 0;
	self.lastY = 0;
	self.lastWasIntersecting = false;
	self.update = function () {
		self.lastX = self.x;
		self.x += self.vx;
		// Clamp boss projectiles within boss platform bounds
		if (self.isBossProjectile && typeof platforms !== "undefined" && platforms.length > 0) {
			// Find the boss platform (the widest one, used for boss)
			var bossPlat = null;
			for (var i = 0; i < platforms.length; i++) {
				if (platforms[i].width >= 1800) {
					// Wide platform for boss
					bossPlat = platforms[i];
					break;
				}
			}
			if (bossPlat) {
				var minX = bossPlat.x;
				var maxX = bossPlat.x + bossPlat.width;
				// Clamp self.x to platform bounds
				if (self.x < minX) {
					self.x = minX;
				}
				if (self.x > maxX) {
					self.x = maxX;
				}
			}
		}
	};
	return self;
});
// Platform class
var Platform = Container.expand(function () {
	var self = Container.call(this);
	var platAsset = self.attachAsset('platformBox', {
		anchorX: 0,
		anchorY: 0
	});
	self.width = platAsset.width;
	self.height = platAsset.height;
	return self;
});
// Player character class
var Player = Container.expand(function () {
	var self = Container.call(this);
	// Attach player asset (red box)
	var playerAsset = self.attachAsset('playerBox', {
		anchorX: 0.5,
		anchorY: 1
	});
	// Physics properties
	self.vx = 0;
	self.vy = 0;
	self.isOnGround = false;
	self.width = playerAsset.width;
	self.height = playerAsset.height;
	// For jump control
	self.jumpRequested = false;
	// Touch down on player (for jump)
	self.down = function (x, y, obj) {
		// Only allow jump if on ground
		if (self.isOnGround) {
			self.jumpRequested = true;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// --- Ava: Render bottomCloud at camera-relative position so it stays fixed like platforms ---
// --- Bottom cloud is now fixed and does not teleport the player ---
if (typeof bottomCloud !== "undefined" && bottomCloud && typeof bottomCloud.x === "number") {
	bottomCloud.displayObject = bottomCloud.displayObject || bottomCloud;
	bottomCloud.displayObject.x = bottomCloud.x - cameraX;
	bottomCloud.displayObject.y = bottomCloud.y;
}
// Boss health bar assets
// --- Game Variables ---
// Tween for animations (jump, enemy movement, etc)
// --- Asset Initialization (shapes) ---
// Sun and cloud assets (example IDs, replace with real asset IDs as needed)
// New bullet figure asset (example: blue ellipse, unique id)
// Unique boss asset
// Boss attack: fire projectile at player
// new kebabBox asset (fullscreen, kebab color)
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
function bossFireProjectile(boss, fast) {
	// Fire 1 or 2 projectiles toward player
	var num = fast ? 2 : 1;
	for (var i = 0; i < num; i++) {
		var proj = new BossBullet();
		proj.x = boss.x;
		proj.y = boss.y + boss.height / 2 - 80 + i * 60;
		// Aim at player
		var dx = player.x - boss.x;
		var dy = player.y - player.height / 2 - proj.y;
		var len = Math.sqrt(dx * dx + dy * dy);
		var speed = fast ? 28 : 18;
		if (len > 0) {
			proj.vx = dx / len * speed;
			proj.vy = dy / len * speed;
		} else {
			proj.vx = speed;
			proj.vy = 0;
		}
		// Mark as boss projectile (for collision logic)
		proj.isBossProjectile = true;
		enemies.push(proj);
		game.addChild(proj);
	}
}
// Boss shockwave: damage player if close to boss when landing
function bossShockwave(boss) {
	// If player is within 220px horizontally and below boss, take damage
	var px = player.x;
	var py = player.y;
	var bx = boss.x;
	var by = boss.y + boss.height / 2;
	if (Math.abs(px - bx) < 220 && py > by) {
		LK.effects.flashScreen(0xff0000, 800);
		playerLives--;
		updateHearts();
		if (playerLives <= 0) {
			gameOver = true;
			LK.showGameOver();
			return;
		}
	}
	// Optional: visual effect for shockwave (flash boss yellow)
	if (boss.displayObject) {
		boss.displayObject.tint = 0xffff00;
		LK.setTimeout(function () {
			if (boss.displayObject) {
				boss.displayObject.tint = 0xffffff;
			}
		}, 200);
	}
}
var GRAVITY = 2.2;
var JUMP_VELOCITY = -54;
var PLAYER_SPEED = 16;
var SCROLL_SPEED = 10;
var LEVEL_LENGTH = 950 * 9 + 600 + 500; // 10 platforms, spacing 950, start at 600, plus last platform width
var player;
var platforms = [];
var coins = [];
var bullets = []; // Bullets array for shooting
var enemies = []; // Array for flying enemies
var coffeeHouse = null;
var boss = null; // Boss instance for 2nd area
var cameraX = 0;
var score = 0;
var distance = 0;
var gameOver = false;
// --- GUI ---
// Hearts (5 total, left-aligned, with spacing)
var heartAssets = [];
var heartSpacing = 120;
var playerLives = 3; // Total lives/can
function updateHearts() {
	for (var i = 0; i < heartAssets.length; i++) {
		if (i < playerLives) {
			heartAssets[i].visible = true;
		} else {
			heartAssets[i].visible = false;
		}
	}
}
for (var i = 0; i < 5; i++) {
	var heart = LK.getAsset('centerCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	heart.x = 180 + i * heartSpacing; // Shifted 150px left from previous position
	heart.y = 100;
	LK.gui.top.addChild(heart);
	heartAssets.push(heart);
}
updateHearts();
var scoreTxt = new Text2('0', {
	size: 100,
	fill: 0xFFF700
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
var distTxt = new Text2('0m', {
	size: 60,
	fill: 0xFFFFFF
});
distTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(distTxt);
distTxt.y = 110;
// --- Level Generation ---
function createLevel() {
	// Clear old
	for (var i = 0; i < platforms.length; i++) {
		platforms[i].destroy();
	}
	for (var i = 0; i < coins.length; i++) {
		coins[i].destroy();
	}
	if (typeof coffeeHouse !== "undefined" && coffeeHouse) {
		coffeeHouse.destroy();
	}
	platforms = [];
	coins = [];
	coffeeHouse = null;
	// Add sun to the sky
	var sun = LK.getAsset('sun', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	sun.x = 300;
	sun.y = 300;
	game.addChild(sun);
	// Add a few clouds at different positions
	var cloud1 = LK.getAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	cloud1.x = 700;
	cloud1.y = 400;
	game.addChild(cloud1);
	var cloud2 = LK.getAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	cloud2.x = 1400;
	cloud2.y = 600;
	game.addChild(cloud2);
	var cloud3 = LK.getAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	cloud3.x = 2000;
	cloud3.y = 350;
	game.addChild(cloud3);
	// --- Bottom Cloud: Always add in level 1, and keep it fixed in that level ---
	// The bottom cloud is a fixed, interactive game object (not a background)
	if (typeof bottomCloud !== "undefined" && bottomCloud && typeof bottomCloud.destroy === "function") {
		bottomCloud.destroy();
	}
	if (typeof currentLevel === "undefined" || currentLevel === 1) {
		bottomCloud = new Platform();
		if (bottomCloud.displayObject) {
			// Replace the platform's asset with a special colored one
			var specialAsset = LK.getAsset('bottomCloudSpecial', {
				anchorX: 0,
				anchorY: 0
			});
			// Remove the old asset if present
			if (bottomCloud.children && bottomCloud.children.length > 0) {
				bottomCloud.removeChild(bottomCloud.children[0]);
			}
			bottomCloud.addChild(specialAsset);
			bottomCloud.displayObject = specialAsset;
			bottomCloud.width = specialAsset.width;
			bottomCloud.height = specialAsset.height;
		}
		bottomCloud.x = 2048 / 2 - bottomCloud.width / 2;
		bottomCloud.y = 2732 - 120 - bottomCloud.height / 2;
		// Add as a normal game object, not as a background
		game.addChild(bottomCloud);
		platforms.push(bottomCloud);
	} else {
		bottomCloud = null;
	}
	// --- Add extra hazards for first level ---
	if (typeof currentLevel === "undefined" || currentLevel === 1) {
		if (typeof hazards === "undefined") {
			hazards = [];
		}
		// Remove old hazards if any
		for (var i = 0; i < hazards.length; i++) {
			if (hazards[i] && typeof hazards[i].destroy === "function") {
				hazards[i].destroy();
			}
		}
		hazards = [];
		// Add 4-6 falling hazards at random X, Y above platforms
		var hazardCount = 4 + Math.floor(Math.random() * 3);
		for (var i = 0; i < hazardCount; i++) {
			var hazard = LK.getAsset('hazard', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			// Place above a random platform (not the first)
			var platIdx = 1;
			if (platforms.length > 2) {
				platIdx = 1 + Math.floor(Math.random() * (platforms.length - 2));
			}
			var plat = platforms[platIdx];
			if (plat && typeof plat.x === "number" && typeof plat.width === "number") {
				hazard.x = plat.x + plat.width / 2 + (Math.random() - 0.5) * 200;
				hazard.y = plat.y - 500 - Math.random() * 400;
			} else {
				// Fallback: place hazard at a default position if platform is missing
				hazard.x = 600 + i * 300;
				hazard.y = 1200 - Math.random() * 400;
			}
			hazard.vy = 12 + Math.random() * 6;
			hazard.width = 180;
			hazard.height = 180;
			hazard.isHazard = true;
			hazards.push(hazard);
			game.addChild(hazard);
		}
	}
	// Platform layout: up/down, not fixed order, player can jump between them
	// 5 levels: 1-4 classic, 5 is boss fight
	var isBossLevel = typeof currentLevel !== "undefined" && currentLevel === 5;
	// Set platform count per level
	var numPlatforms = 10;
	if (typeof currentLevel !== "undefined") {
		if (currentLevel === 1) numPlatforms = 20;else if (currentLevel === 2) numPlatforms = 25;else if (currentLevel === 3) numPlatforms = 30;else if (currentLevel === 4) numPlatforms = 40;else if (currentLevel === 5) numPlatforms = 30;
	}
	var platSpacingX = 950; // Further increased horizontal spacing for much more space
	var platMinY = 800; // Lowered min Y for more vertical play area
	var platMaxY = 1900; // Raised max Y for more vertical play area
	// Calculate max jump height based on physics
	// vy = JUMP_VELOCITY, gravity = GRAVITY
	// maxJumpHeight = - (vy^2) / (2 * gravity)
	var maxJumpHeight = -(JUMP_VELOCITY * JUMP_VELOCITY) / (2 * GRAVITY);
	// Use 90% of maxJumpHeight for margin of error
	var platformGapY = Math.floor(maxJumpHeight * 0.9);
	var lastY = 1800;
	// (Removed initial spawn platform and its coin)
	for (var i = 0; i < numPlatforms; i++) {
		// If this is the last platform of the boss level, add a wide area instead of a platform
		if (isBossLevel && i === numPlatforms - 1) {
			// Create a wide area using a platform asset, but much wider
			var wideArea = new Platform();
			wideArea.x = 600 + i * platSpacingX;
			wideArea.y = lastY;
			wideArea.width = 2048; // Full screen width
			wideArea.height = 300; // Taller for effect
			// Set the display object size as well
			if (wideArea.displayObject) {
				wideArea.displayObject.width = wideArea.width;
				wideArea.displayObject.height = wideArea.height;
			}
			platforms.push(wideArea);
			game.addChild(wideArea);
			// Optionally, add a coin or heart in the middle of the wide area
			var coin = new Coin();
			coin.x = wideArea.x + wideArea.width / 2;
			coin.y = wideArea.y - 80;
			coins.push(coin);
			game.addChild(coin);
			// Add boss at the right end of the wide area
			if (typeof boss !== "undefined" && boss) {
				boss.destroy();
			}
			// Remove all hazards before boss fight
			if (typeof hazards !== "undefined" && hazards.length) {
				for (var h = 0; h < hazards.length; h++) {
					if (hazards[h] && typeof hazards[h].destroy === "function") {
						hazards[h].destroy();
					}
				}
			}
			hazards = [];
			boss = new Boss();
			// Place boss so its feet are 200px above the platform
			boss.x = wideArea.x + wideArea.width - boss.width / 2 - 60; // Near right edge
			// Boss anchorY is 0.5, so y is at center. To put feet 200px above platform: y = platform.y + platform.height - boss.height/2 - 200
			boss.y = wideArea.y + wideArea.height - boss.height / 2 - 200;
			// Set boss.groundY to correct y so boss doesn't jump to top
			boss.groundY = boss.y;
			game.addChild(boss);
			// No checkpoint on the wide area
			continue;
		}
		var plat = new Platform();
		plat.x = 600 + i * platSpacingX;
		// Alternate up/down, but keep within jumpable range
		if (i === 0) {
			plat.y = lastY;
		} else {
			// Randomly go up or down, but clamp to min/max
			var deltaY = (Math.random() > 0.5 ? -1 : 1) * (platformGapY + Math.floor(Math.random() * 40) - 20); // Small random offset
			plat.y = lastY + deltaY;
			if (plat.y < platMinY) {
				plat.y = platMinY;
			}
			if (plat.y > platMaxY) {
				plat.y = platMaxY;
			}
			lastY = plat.y;
		}
		platforms.push(plat);
		game.addChild(plat);
		// Place a coin above every platform, but rarely replace with a heart (extra life)
		if (Math.random() < 0.07) {
			// ~7% chance, very rare
			var heart = LK.getAsset('centerCircle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			heart.x = plat.x + plat.width / 2;
			heart.y = plat.y - 80;
			heart.isHeart = true;
			coins.push(heart);
			game.addChild(heart);
		} else {
			var coin = new Coin();
			coin.x = plat.x + plat.width / 2;
			coin.y = plat.y - 80;
			coins.push(coin);
			game.addChild(coin);
		}
		// Add a checkpoint marker every 10th platform (not the first platform)
		if (i > 0 && i % 10 === 0) {
			var checkpoint = LK.getAsset('centerCircle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			checkpoint.x = plat.x + plat.width / 2;
			checkpoint.y = plat.y - 120;
			checkpoint.width = 120;
			checkpoint.height = 120;
			checkpoint.isCheckpoint = true;
			checkpoint.platformIndex = i;
			game.addChild(checkpoint);
			// Store checkpoint objects in an array for respawn logic
			if (typeof checkpoints === "undefined") {
				checkpoints = [];
			}
			checkpoints.push(checkpoint);
		}
	}
	// Add coffee house on the last platform for levels 1, 2, 3, 4 (not boss level)
	if (platforms.length > 0 && (typeof currentLevel === "undefined" || currentLevel === 1 || currentLevel === 2 || currentLevel === 3 || currentLevel === 4)) {
		var lastPlat = platforms[platforms.length - 1];
		coffeeHouse = LK.getAsset('coffeeHouse', {
			anchorX: 0.5,
			anchorY: 1
		});
		coffeeHouse.x = lastPlat.x + lastPlat.width / 2;
		coffeeHouse.y = lastPlat.y;
		game.addChild(coffeeHouse);
	}
}
// --- Player Initialization ---
// Track the last safe platform index for respawn
var lastSafePlatformIndex = 0;
// Track the platform the player fell from for respawn
var lastFallenPlatformIndex = 0;
function resetPlayer(respawnToLastSafe) {
	if (player) {
		player.destroy();
	}
	player = new Player();
	// Place player on the start platform or the platform where they fell if requested
	if (platforms.length > 0) {
		var platIdx = 0;
		if (respawnToLastSafe && typeof lastFallenPlatformIndex === "number" && lastFallenPlatformIndex >= 0 && lastFallenPlatformIndex < platforms.length) {
			platIdx = lastFallenPlatformIndex;
		} else if (respawnToLastSafe && typeof lastSafePlatformIndex === "number" && lastSafePlatformIndex >= 0 && lastSafePlatformIndex < platforms.length) {
			platIdx = lastSafePlatformIndex;
		}
		player.x = platforms[platIdx].x + platforms[platIdx].width / 2;
		player.y = platforms[platIdx].y;
	} else {
		player.x = 200;
		player.y = 2200;
	}
	player.vx = 0;
	player.vy = 0;
	player.isOnGround = false;
	game.addChild(player);
	// --- Ava: Stop auto-move and movement if spawning on first platform ---
	if (typeof autoMoveRightActive === "undefined") {
		autoMoveRightActive = false;
	}
	if (typeof moveDir === "undefined") {
		moveDir = 0;
	}
	if (platIdx === 0) {
		autoMoveRightActive = false;
		moveDir = 0;
		// Set a flag to require left button press to resume movement
		player.waitingForLeftBtn = true;
	} else {
		player.waitingForLeftBtn = false;
	}
}
// --- Camera ---
function updateCamera() {
	// Camera always follows player, no clamping
	cameraX = player.x - 600;
	// Move all game objects (except GUI) by -cameraX
	for (var i = 0; i < platforms.length; i++) {
		platforms[i].xScreen = platforms[i].x - cameraX;
	}
	for (var i = 0; i < coins.length; i++) {
		coins[i].xScreen = coins[i].x - cameraX;
	}
	player.xScreen = player.x - cameraX;
	// Move coffeeHouse relative to camera
	if (coffeeHouse && platforms.length > 0) {
		var lastPlat = platforms[platforms.length - 1];
		coffeeHouse.xScreen = coffeeHouse.x - cameraX;
		coffeeHouse.yScreen = coffeeHouse.y;
	}
	// (hazard removed)
}
// --- Utility: AABB collision ---
function intersectsAABB(a, b) {
	return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
}
// --- Touch Controls ---
// On-screen left, right, and jump buttons (bottom left corner)
// Only these buttons control movement/jump; fire is still tap/double-tap on right side
var moveDir = 0; // -1 = left, 1 = right, 0 = none
var leftBtn, rightBtn, jumpBtn;
var leftBtnPressed = false,
	rightBtnPressed = false,
	jumpBtnPressed = false;
// Create left button
leftBtn = LK.getAsset('btnLeftBg', {
	anchorX: 0.5,
	anchorY: 0.5
});
leftBtn.x = 180;
leftBtn.y = 2732 - 220;
leftBtn.width = 260;
leftBtn.height = 260;
game.addChild(leftBtn);
var leftIcon = LK.getAsset('btnLeftIcon', {
	anchorX: 0.5,
	anchorY: 0.5
});
leftIcon.x = leftBtn.x;
leftIcon.y = leftBtn.y;
leftIcon.width = 140;
leftIcon.height = 140;
game.addChild(leftIcon);
// Create right button
rightBtn = LK.getAsset('btnRightBg', {
	anchorX: 0.5,
	anchorY: 0.5
});
rightBtn.x = 470 + 150 - 125;
rightBtn.y = 2732 - 220;
rightBtn.width = 260;
rightBtn.height = 260;
game.addChild(rightBtn);
var rightIcon = LK.getAsset('btnRightIcon', {
	anchorX: 0.5,
	anchorY: 0.5
});
rightIcon.x = rightBtn.x;
rightIcon.y = rightBtn.y;
rightIcon.width = 140;
rightIcon.height = 140;
game.addChild(rightIcon);
// Create jump button
jumpBtn = LK.getAsset('btnJumpBg', {
	anchorX: 0.5,
	anchorY: 0.5
});
jumpBtn.x = 220 + 200 - 90;
jumpBtn.y = 2732 - 520;
jumpBtn.width = 260;
jumpBtn.height = 260;
game.addChild(jumpBtn);
var jumpIcon = LK.getAsset('btnJumpIcon', {
	anchorX: 0.5,
	anchorY: 0.5
});
jumpIcon.x = jumpBtn.x;
jumpIcon.y = jumpBtn.y;
jumpIcon.width = 140;
jumpIcon.height = 140;
game.addChild(jumpIcon);
// Create fire button (bottom right, red circle)
var fireBtn = LK.getAsset('btnFireBg', {
	anchorX: 0.5,
	anchorY: 0.5
});
fireBtn.x = 2048 - 180;
fireBtn.y = 2732 - 220;
fireBtn.width = 260;
fireBtn.height = 260;
game.addChild(fireBtn);
// Terlik ikonunu fire butonun ortasına ekle
var terlikIcon = LK.getAsset('terlikIcon', {
	anchorX: 0.5,
	anchorY: 0.5
});
terlikIcon.x = fireBtn.x;
terlikIcon.y = fireBtn.y;
terlikIcon.width = 160;
terlikIcon.height = 160;
game.addChild(terlikIcon);
// Helper to check if a point is inside a button
function isInsideBtn(btn, x, y) {
	var bx = btn.x,
		by = btn.y,
		bw = btn.width,
		bh = btn.height;
	// LK.gui is scaled, so use screen coordinates directly
	return x >= bx - bw / 2 && x <= bx + bw / 2 && y >= by - bh / 2 && y <= by + bh / 2;
}
// Overwrite game.down for button controls
game.down = function (x, y, obj) {
	if (gameOver) {
		return;
	}
	// Check if pressed on left, right, or jump button
	if (isInsideBtn(leftBtn, x, y)) {
		leftBtnPressed = true;
		// --- Ava: If waitingForLeftBtn, allow movement to resume only on left button press ---
		if (player && player.waitingForLeftBtn) {
			player.waitingForLeftBtn = false;
			moveDir = -1;
		} else if (!player.waitingForLeftBtn) {
			moveDir = -1;
		}
		// Stop auto-move right if active
		if (typeof autoMoveRightActive !== "undefined" && autoMoveRightActive) {
			autoMoveRightActive = false;
		}
	}
	if (isInsideBtn(rightBtn, x, y)) {
		rightBtnPressed = true;
		moveDir = 1;
		// --- Double-tap detection for right button ---
		if (typeof rightBtnLastTapTime === "undefined") {
			rightBtnLastTapTime = 0;
			rightBtnTapCount = 0;
		}
		var now = Date.now();
		if (now - rightBtnLastTapTime < 400) {
			rightBtnTapCount++;
		} else {
			rightBtnTapCount = 1;
		}
		rightBtnLastTapTime = now;
		if (rightBtnTapCount === 2) {
			// Toggle auto-move right: if already active, turn off; if not, turn on
			if (typeof autoMoveRightActive === "undefined") {
				autoMoveRightActive = false;
			}
			if (autoMoveRightActive) {
				autoMoveRightActive = false;
				moveDir = 0;
			} else {
				autoMoveRightActive = true;
				moveDir = 1;
			}
			rightBtnTapCount = 0;
		}
	}
	if (isInsideBtn(jumpBtn, x, y)) {
		jumpBtnPressed = true;
		if (player.isOnGround) {
			player.jumpRequested = true;
		}
	}
	// Fire button: shoot bullet
	if (typeof fireBtn !== "undefined" && isInsideBtn(fireBtn, x, y)) {
		var bullet = new Bullet();
		bullet.x = player.x;
		bullet.y = player.y - player.height / 2;
		bullet.lastX = bullet.x;
		bullet.vx = 40;
		bullet.vy = 0;
		bullet.isControlled = false;
		bullets.push(bullet);
		game.addChild(bullet);
		return;
	}
	// If not on any button, allow fire mechanic as before (right half of screen)
	if (!isInsideBtn(leftBtn, x, y) && !isInsideBtn(rightBtn, x, y) && !isInsideBtn(jumpBtn, x, y)) {
		// Fire a bullet only if this is a double-tap (within 350ms) on the right side
		if (x > 2048 / 2) {
			if (typeof lastFireTapTime === "undefined") {
				lastFireTapTime = 0;
			}
			var now = Date.now();
			if (now - lastFireTapTime < 350) {
				// Double-tap detected: fire bullet
				var bullet = new Bullet();
				bullet.x = player.x;
				bullet.y = player.y - player.height / 2;
				bullet.lastX = bullet.x;
				// Set initial direction to right, but allow control
				bullet.vx = 0;
				bullet.vy = 0;
				bullet.isControlled = true; // Mark as controlled
				bullets.push(bullet);
				game.addChild(bullet);
				// Store the controlled bullet reference for move/up
				game.controlledBullet = bullet;
				lastFireTapTime = 0; // Reset
			} else {
				// First tap: just record time
				lastFireTapTime = now;
			}
		}
	}
};
// Overwrite game.up for button controls
game.up = function (x, y, obj) {
	// Release movement/jump on button up
	if (isInsideBtn(leftBtn, x, y)) {
		leftBtnPressed = false;
		if (!rightBtnPressed) {
			moveDir = 0;
		} else {
			moveDir = 1;
		}
	}
	if (isInsideBtn(rightBtn, x, y)) {
		rightBtnPressed = false;
		if (!leftBtnPressed) {
			moveDir = 0;
		} else {
			moveDir = -1;
		}
	}
	if (isInsideBtn(jumpBtn, x, y)) {
		jumpBtnPressed = false;
	}
	// Release bullet control on touch up
	if (game.controlledBullet && game.controlledBullet.isControlled) {
		game.controlledBullet.isControlled = false;
		game.controlledBullet = null;
	}
};
// Overwrite game.move for button controls and bullet direction
game.move = function (x, y, obj) {
	// If dragging on left/right button, update moveDir
	if (leftBtnPressed && isInsideBtn(leftBtn, x, y)) {
		moveDir = -1;
	} else if (rightBtnPressed && isInsideBtn(rightBtn, x, y)) {
		moveDir = 1;
	} else if (!leftBtnPressed && !rightBtnPressed) {
		moveDir = 0;
	}
	// If a controlled bullet exists, update its velocity based on drag direction
	if (game.controlledBullet && game.controlledBullet.isControlled) {
		var bx = game.controlledBullet.x;
		var by = game.controlledBullet.y;
		var gx = x + cameraX;
		var gy = y;
		var dx = gx - bx;
		var dy = gy - by;
		var len = Math.sqrt(dx * dx + dy * dy);
		if (len > 0) {
			// Set bullet speed (fixed magnitude, e.g. 40 px/frame)
			var speed = 40;
			game.controlledBullet.vx = dx / len * speed;
			game.controlledBullet.vy = dy / len * speed;
		}
	}
};
// --- Game Update Loop ---
game.update = function () {
	if (gameOver) {
		return;
	}
	// --- Player Movement ---
	// Auto-move right logic
	if (typeof autoMoveRightActive === "undefined") {
		autoMoveRightActive = false;
	}
	if (autoMoveRightActive) {
		moveDir = 1;
	}
	// --- Ava: Prevent all movement if waitingForLeftBtn is true ---
	if (player && player.waitingForLeftBtn) {
		player.vx = 0;
	} else {
		player.vx = moveDir * PLAYER_SPEED;
	}
	// Apply gravity
	player.vy += GRAVITY;
	// Jump
	if (player.jumpRequested) {
		player.vy = JUMP_VELOCITY;
		player.jumpRequested = false;
		player.isOnGround = false;
	}
	// Move horizontally, check collisions
	player.x += player.vx;
	var collidedX = false;
	for (var i = 0; i < platforms.length; i++) {
		var plat = platforms[i];
		if (intersectsAABB({
			x: player.x - player.width / 2,
			y: player.y - player.height,
			width: player.width,
			height: player.height
		}, {
			x: plat.x,
			y: plat.y,
			width: plat.width,
			height: plat.height
		})) {
			// Collided horizontally, push player out
			if (player.vx > 0) {
				player.x = plat.x - player.width / 2;
			} else if (player.vx < 0) {
				player.x = plat.x + plat.width + player.width / 2;
			}
			collidedX = true;
		}
	}
	// Move vertically, check collisions
	player.y += player.vy;
	var collidedY = false;
	player.isOnGround = false;
	for (var i = 0; i < platforms.length; i++) {
		var plat = platforms[i];
		if (intersectsAABB({
			x: player.x - player.width / 2,
			y: player.y - player.height,
			width: player.width,
			height: player.height
		}, {
			x: plat.x,
			y: plat.y,
			width: plat.width,
			height: plat.height
		})) {
			// Collided vertically
			if (player.vy > 0) {
				// Falling, land on platform
				player.y = plat.y;
				player.vy = 0;
				player.isOnGround = true;
				// Update last safe platform index to this platform
				lastSafePlatformIndex = i;
				// If this is the boss platform and boss exists, start boss firing
				if (boss && plat.width >= 1800 &&
				// Boss platform is the wide one
				typeof boss.bossStartFiring !== "undefined") {
					boss.bossStartFiring = true;
				}
			} else if (player.vy < 0) {
				// Hitting head
				player.y = plat.y + plat.height + player.height;
				player.vy = 0;
			}
			collidedY = true;
		}
	}
	// --- Bottom cloud is now fixed and does not teleport the player ---
	// --- Coin/Heart Collection ---
	for (var i = coins.length - 1; i >= 0; i--) {
		var coin = coins[i];
		if (intersectsAABB({
			x: player.x - player.width / 2,
			y: player.y - player.height,
			width: player.width,
			height: player.height
		}, {
			x: coin.x - coin.width / 2,
			y: coin.y - coin.height / 2,
			width: coin.width,
			height: coin.height
		})) {
			// If this is a heart (centerCircle), increase playerLives, up to max 5
			if (coin.isHeart) {
				if (playerLives < 5) {
					playerLives++;
					updateHearts();
				} else {
					// If already at max health, give 20 points instead
					score += 20;
					scoreTxt.setText(score);
					// Every 20 points, convert to 1 life (up to max 5)
					if (score >= 20) {
						var extraLives = Math.floor(score / 20);
						var livesToAdd = Math.min(extraLives, 5 - playerLives);
						if (livesToAdd > 0) {
							playerLives += livesToAdd;
							updateHearts();
							score -= livesToAdd * 20;
							scoreTxt.setText(score);
						}
					}
				}
			} else {
				// Otherwise, it's a coin, increase score
				score += 1;
				scoreTxt.setText(score);
				// Every 20 points, convert to 1 life (up to max 5)
				if (score >= 20) {
					var extraLives = Math.floor(score / 20);
					var livesToAdd = Math.min(extraLives, 5 - playerLives);
					if (livesToAdd > 0) {
						playerLives += livesToAdd;
						updateHearts();
						score -= livesToAdd * 20;
						scoreTxt.setText(score);
					}
				}
			}
			coin.destroy();
			coins.splice(i, 1);
		}
	}
	// --- Checkpoint Collection ---
	// Only mark checkpoint as collected when falling, not on touch
	// (handled in fall logic below)
	// --- Bullets Update ---
	var bossFightActive = boss && boss.bossStartFiring === true;
	// Only update bullets if not in boss fight, or if they are boss/player bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		// During boss fight, only allow boss/player bullets to move (skip all others)
		if (bossFightActive && !bullet.isBossProjectile) {
			// Pause non-boss bullets (do not update position)
			// Optionally, you could hide or destroy them here if desired
			continue;
		}
		bullet.update();
		// Remove bullet if off screen (right side)
		if (bullet.lastX <= LEVEL_LENGTH && bullet.x > LEVEL_LENGTH) {
			bullet.destroy();
			bullets.splice(i, 1);
			continue;
		}
		// Remove bullet if off left or out of vertical bounds, respawn at top if falls below
		if (bullet.x < 0 || bullet.y < 0) {
			bullet.destroy();
			bullets.splice(i, 1);
			continue;
		} else if (bullet.y > 2732) {
			// Respawn bullet at the top of the screen, keep its x and vx/vy
			bullet.y = 0;
			// Optionally, you can randomize x or keep as is
			// bullet.x = Math.random() * 2048;
			// Keep lastY in sync to avoid false triggers
			bullet.lastY = bullet.y;
		}
		// --- Bullet stuck detection: remove if not moving for 12 frames ---
		if (typeof bullet.stuckFrames === "undefined") {
			bullet.stuckFrames = 0;
		}
		if (Math.abs(bullet.x - bullet.lastX) < 1 && Math.abs(bullet.y - bullet.lastY) < 1) {
			bullet.stuckFrames++;
			if (bullet.stuckFrames > 12) {
				bullet.destroy();
				bullets.splice(i, 1);
				continue;
			}
		} else {
			bullet.stuckFrames = 0;
		}
		// Render bullet at camera-relative position
		bullet.displayObject = bullet.displayObject || bullet;
		bullet.displayObject.x = bullet.x - cameraX;
		bullet.displayObject.y = bullet.y;
	}
	// --- Auto-fire at boss when visible ---
	if (!bossFightActive) {
		if (boss && _typeof(boss) === "object" && typeof boss.x === "number" && typeof boss.y === "number") {
			// Check if boss is visible on screen (simple check: boss.x - cameraX in [0, 2048])
			var bossScreenX = boss.x - cameraX;
			if (bossScreenX > 0 && bossScreenX < 2048) {
				// Only fire if enough time has passed since last auto-fire
				if (typeof bossAutoFireTimer === "undefined") {
					bossAutoFireTimer = 0;
				}
				bossAutoFireTimer++;
				// Fire every 18 frames (~3 shots per second)
				if (bossAutoFireTimer > 18) {
					bossAutoFireTimer = 0;
					// Create a bullet aimed at boss
					var autoBullet = new Bullet();
					autoBullet.x = player.x;
					autoBullet.y = player.y - player.height / 2;
					autoBullet.lastX = autoBullet.x;
					// Aim at boss center
					var dx = boss.x - autoBullet.x;
					var dy = boss.y - boss.height / 2 - autoBullet.y;
					var len = Math.sqrt(dx * dx + dy * dy);
					var speed = 40;
					if (len > 0) {
						autoBullet.vx = dx / len * speed;
						autoBullet.vy = dy / len * speed;
					} else {
						autoBullet.vx = speed;
						autoBullet.vy = 0;
					}
					autoBullet.isControlled = false;
					bullets.push(autoBullet);
					game.addChild(autoBullet);
				}
			} else {
				// Reset timer if boss is not visible
				bossAutoFireTimer = 18;
			}
		}
	}
	// --- Enemy Update & Collision ---
	if (!bossFightActive) {
		// Delay enemy movement for 3 seconds after game start
		if (typeof enemyStartDelay === "undefined") {
			enemyStartDelay = 180;
		} // 3 seconds at 60fps
		if (enemyStartDelay > 0) {
			enemyStartDelay--;
		} else {
			if (typeof enemySpawnTimer === "undefined") {
				enemySpawnTimer = 0;
			}
			enemySpawnTimer++;
			// Spawn a new enemy every 120-200 frames (randomized)
			if (enemySpawnTimer > 120 + Math.floor(Math.random() * 80)) {
				var enemy = new Enemy();
				// Spawn at right edge, random Y within play area
				enemy.x = cameraX + 2048 + enemy.width / 2;
				// Avoid top 200px and bottom 400px
				enemy.y = 400 + Math.random() * (2100 - 400);
				enemy.lastX = enemy.x;
				enemy.lastWasIntersecting = false;
				enemies.push(enemy);
				game.addChild(enemy);
				enemySpawnTimer = 0;
			}
			// Update and render enemies
			for (var i = enemies.length - 1; i >= 0; i--) {
				var enemy = enemies[i];
				enemy.update();
				// Remove if off left side
				if (enemy.lastX >= -enemy.width && enemy.x < -enemy.width) {
					enemy.destroy();
					enemies.splice(i, 1);
					continue;
				}
				// Render at camera-relative position
				enemy.displayObject = enemy.displayObject || enemy;
				enemy.displayObject.x = enemy.x - cameraX;
				enemy.displayObject.y = enemy.y;
				// --- Bullet-Enemy Collision ---
				var enemyDestroyed = false;
				for (var j = bullets.length - 1; j >= 0; j--) {
					var bullet = bullets[j];
					// Boss projectiles do not collide with other enemies
					if (enemy.isBossProjectile) {
						continue;
					}
					// Use AABB for bullet-enemy collision
					if (intersectsAABB({
						x: bullet.x - bullet.width / 2,
						y: bullet.y - bullet.height / 2,
						width: bullet.width,
						height: bullet.height
					}, {
						x: enemy.x - enemy.width / 2,
						y: enemy.y - enemy.height / 2,
						width: enemy.width,
						height: enemy.height
					})) {
						// Destroy both bullet and enemy
						bullet.destroy();
						bullets.splice(j, 1);
						enemy.destroy();
						enemies.splice(i, 1);
						// Optionally, add score or effect here
						score += 5;
						scoreTxt.setText(score);
						// Every 20 points, convert to 1 life (up to max 5)
						if (score >= 20) {
							var extraLives = Math.floor(score / 20);
							var livesToAdd = Math.min(extraLives, 5 - playerLives);
							if (livesToAdd > 0) {
								playerLives += livesToAdd;
								updateHearts();
								score -= livesToAdd * 20;
								scoreTxt.setText(score);
							}
						}
						enemyDestroyed = true;
						break;
					}
				}
				if (enemyDestroyed) {
					continue;
				}
				// Check collision with player (only on the frame it starts)
				var isIntersecting = intersectsAABB({
					x: player.x - player.width / 2,
					y: player.y - player.height,
					width: player.width,
					height: player.height
				}, {
					x: enemy.x - enemy.width / 2,
					y: enemy.y - enemy.height / 2,
					width: enemy.width,
					height: enemy.height
				});
				if (!enemy.lastWasIntersecting && isIntersecting) {
					// If this is a boss projectile, damage player and destroy projectile
					if (enemy.isBossProjectile) {
						LK.effects.flashScreen(0xff0000, 1000);
						playerLives--;
						updateHearts();
						if (playerLives <= 0) {
							gameOver = true;
							LK.showGameOver();
							return;
						}
						enemy.destroy();
						enemies.splice(i, 1);
						continue;
					}
					// Player hit by enemy!
					LK.effects.flashScreen(0xff0000, 1000);
					playerLives--;
					updateHearts();
					if (playerLives <= 0) {
						gameOver = true;
						LK.showGameOver();
						return;
					}
					// Do not respawn or move player, just continue playing
				}
				enemy.lastWasIntersecting = isIntersecting;
			}
		} // end else for enemyStartDelay
	}
	// --- Boss Fight: Boss projectiles damage player ---
	if (bossFightActive) {
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			enemy.update();
			// Remove if off left side or out of bounds
			if (enemy.lastX >= -enemy.width && enemy.x < -enemy.width) {
				enemy.destroy();
				enemies.splice(i, 1);
				continue;
			}
			// Render at camera-relative position
			enemy.displayObject = enemy.displayObject || enemy;
			enemy.displayObject.x = enemy.x - cameraX;
			enemy.displayObject.y = enemy.y;
			// Only check boss projectiles for player collision
			if (enemy.isBossProjectile) {
				var isIntersecting = intersectsAABB({
					x: player.x - player.width / 2,
					y: player.y - player.height,
					width: player.width,
					height: player.height
				}, {
					x: enemy.x - enemy.width / 2,
					y: enemy.y - enemy.height / 2,
					width: enemy.width,
					height: enemy.height
				});
				if (!enemy.lastWasIntersecting && isIntersecting) {
					LK.effects.flashScreen(0xff0000, 1000);
					playerLives--;
					updateHearts();
					if (playerLives <= 0) {
						gameOver = true;
						LK.showGameOver();
						return;
					}
					enemy.destroy();
					enemies.splice(i, 1);
					continue;
				}
				enemy.lastWasIntersecting = isIntersecting;
			}
		}
	}
	// --- Boss Update & Collision ---
	// Boss health bar setup (global, so only one at a time)
	if (typeof bossHealthBarBg === "undefined") {
		bossHealthBarBg = null;
	}
	if (typeof bossHealthBarFill === "undefined") {
		bossHealthBarFill = null;
	}
	if (boss && typeof boss.update === "function") {
		boss.update();
		// Render boss at camera-relative position
		boss.displayObject = boss.displayObject || boss;
		boss.displayObject.x = boss.x - cameraX;
		boss.displayObject.y = boss.y;
		// --- Boss Health Bar ---
		// Create health bar if not exists
		if (!bossHealthBarBg) {
			// Background bar (custom asset)
			bossHealthBarBg = LK.getAsset('bossHealthBarBg', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			bossHealthBarBg.alpha = 0.7;
			game.addChild(bossHealthBarBg);
			// Fill bar (custom asset)
			bossHealthBarFill = LK.getAsset('bossHealthBarFill', {
				anchorX: 0,
				anchorY: 0.5
			});
			bossHealthBarFill.alpha = 0.95;
			game.addChild(bossHealthBarFill);
		}
		// Update health bar position above boss
		if (bossHealthBarBg && bossHealthBarFill) {
			// Bar width and percent
			var barW = boss.width * 0.8;
			var barH = 44;
			var fillW = boss.width * 0.78;
			var fillH = 32;
			var percent = Math.max(0, boss.hp / 10);
			// Position above boss head (50px above top)
			var barX = boss.x - cameraX;
			var barY = boss.y - boss.height / 2 - 50;
			bossHealthBarBg.x = barX;
			bossHealthBarBg.y = barY;
			bossHealthBarBg.width = barW;
			bossHealthBarBg.height = barH;
			bossHealthBarBg.visible = true;
			bossHealthBarFill.x = barX - fillW / 2;
			bossHealthBarFill.y = barY;
			bossHealthBarFill.width = fillW * percent;
			bossHealthBarFill.height = fillH;
			bossHealthBarFill.visible = true;
		}
		// Bullet-boss collision
		for (var j = bullets.length - 1; j >= 0; j--) {
			var bullet = bullets[j];
			if (intersectsAABB({
				x: bullet.x - bullet.width / 2,
				y: bullet.y - bullet.height / 2,
				width: bullet.width,
				height: bullet.height
			}, {
				x: boss.x - boss.width / 2,
				y: boss.y - boss.height / 2,
				width: boss.width,
				height: boss.height
			})) {
				// Boss can only be damaged if not shielded, or if weak spot is open
				if (!boss.shieldActive && (boss.phase === 1 || boss.weakSpotOpen || boss.phase === 1)) {
					boss.hp--;
					bullet.destroy();
					bullets.splice(j, 1);
					// Flash boss on hit
					LK.effects.flashObject(boss, 0xff0000, 200);
					// If boss defeated
					if (boss.hp <= 0) {
						LK.effects.flashScreen(0x00ff00, 1000);
						boss.destroy();
						boss = null;
						score += 50;
						scoreTxt.setText(score);
						// Remove boss health bar
						if (bossHealthBarBg) {
							bossHealthBarBg.visible = false;
							bossHealthBarBg.destroy();
							bossHealthBarBg = null;
						}
						if (bossHealthBarFill) {
							bossHealthBarFill.visible = false;
							bossHealthBarFill.destroy();
							bossHealthBarFill = null;
						}
						// End the game with a win when boss is defeated
						LK.setScore(score);
						LK.showYouWin();
						return;
					}
					break;
				} else {
					// Boss is shielded or not vulnerable, bullet bounces off (destroy bullet)
					bullet.destroy();
					bullets.splice(j, 1);
					// Optional: flash boss blue for shield
					if (boss.shieldActive && boss.displayObject) {
						LK.effects.flashObject(boss, 0x44aaff, 120);
					}
					break;
				}
			}
		}
		// Boss-player collision (only on the frame it starts)
		if (boss) {
			// Defensive: boss may have been destroyed above
			var bossIntersect = intersectsAABB({
				x: player.x - player.width / 2,
				y: player.y - player.height,
				width: player.width,
				height: player.height
			}, {
				x: boss.x - boss.width / 2,
				y: boss.y - boss.height / 2,
				width: boss.width,
				height: boss.height
			});
			if (!boss.lastWasIntersecting && bossIntersect) {
				LK.effects.flashScreen(0xff0000, 1000);
				playerLives--;
				updateHearts();
				if (playerLives <= 0) {
					gameOver = true;
					LK.showGameOver();
					// Remove boss health bar
					if (bossHealthBarBg) {
						bossHealthBarBg.visible = false;
						bossHealthBarBg.destroy();
						bossHealthBarBg = null;
					}
					if (bossHealthBarFill) {
						bossHealthBarFill.visible = false;
						bossHealthBarFill.destroy();
						bossHealthBarFill = null;
					}
					return;
				}
			}
			boss.lastWasIntersecting = bossIntersect;
		}
	} else {
		// No boss: remove health bar if exists
		if (bossHealthBarBg) {
			bossHealthBarBg.visible = false;
			bossHealthBarBg.destroy();
			bossHealthBarBg = null;
		}
		if (bossHealthBarFill) {
			bossHealthBarFill.visible = false;
			bossHealthBarFill.destroy();
			bossHealthBarFill = null;
		}
	}
	// --- Hazard Update & Collision ---
	// Remove hazards during boss fight (currentLevel === 2 and boss exists)
	if (typeof hazards !== "undefined" && hazards.length && (typeof currentLevel === "undefined" || currentLevel === 1 || typeof currentLevel !== "undefined" && currentLevel === 2 && !boss)) {
		for (var i = hazards.length - 1; i >= 0; i--) {
			var hazard = hazards[i];
			// Move hazard down
			hazard.y += hazard.vy || 14;
			// Render at camera-relative position
			hazard.displayObject = hazard.displayObject || hazard;
			hazard.displayObject.x = hazard.x - cameraX;
			hazard.displayObject.y = hazard.y;
			// Remove if off screen
			if (hazard.y > 2732 + 200) {
				hazard.destroy();
				hazards.splice(i, 1);
				continue;
			}
			// Check collision with player (AABB)
			if (player.x - player.width / 2 < hazard.x + hazard.width / 2 && player.x + player.width / 2 > hazard.x - hazard.width / 2 && player.y - player.height < hazard.y + hazard.height / 2 && player.y > hazard.y - hazard.height / 2) {
				LK.effects.flashScreen(0xff0000, 800);
				playerLives--;
				updateHearts();
				hazard.destroy();
				hazards.splice(i, 1);
				if (playerLives <= 0) {
					gameOver = true;
					LK.showGameOver();
					return;
				}
			}
		}
	} else if (typeof hazards !== "undefined" && hazards.length && typeof currentLevel !== "undefined" && currentLevel === 2 && boss) {
		// If boss fight is active, despawn all hazards immediately
		for (var i = hazards.length - 1; i >= 0; i--) {
			if (hazards[i] && typeof hazards[i].destroy === "function") {
				hazards[i].destroy();
			}
		}
		hazards = [];
	}
	// --- Camera & Distance ---
	updateCamera();
	// Move all objects to screen position (for rendering only, do not overwrite world position)
	for (var i = 0; i < platforms.length; i++) {
		platforms[i].displayObject = platforms[i].displayObject || platforms[i];
		platforms[i].displayObject.x = platforms[i].xScreen;
		platforms[i].displayObject.y = platforms[i].y;
	}
	for (var i = 0; i < coins.length; i++) {
		coins[i].displayObject = coins[i].displayObject || coins[i];
		coins[i].displayObject.x = coins[i].xScreen;
		coins[i].displayObject.y = coins[i].y;
	}
	player.displayObject = player.displayObject || player;
	player.displayObject.x = player.xScreen;
	player.displayObject.y = player.y;
	// Move coffeeHouse to screen position if exists
	if (coffeeHouse && typeof coffeeHouse.xScreen !== "undefined") {
		coffeeHouse.x = coffeeHouse.xScreen;
		coffeeHouse.y = coffeeHouse.yScreen;
	}
	// (hazard removed)
	// --- Distance ---
	distance = Math.floor((player.x + cameraX) / 10);
	distTxt.setText(distance + "m");
	// --- Win/Lose Conditions ---
	// Fall off screen
	if (player.y > 2732) {
		LK.effects.flashScreen(0xff0000, 1000);
		playerLives--;
		updateHearts();
		// Find the platform the player was last above before falling
		if (typeof lastFallenPlatformIndex === "undefined") {
			lastFallenPlatformIndex = 0;
		}
		lastFallenPlatformIndex = 0;
		var minDist = Infinity;
		for (var i = 0; i < platforms.length; i++) {
			var plat = platforms[i];
			// Check if player was horizontally above this platform when falling
			if (player.x + player.width / 2 >= plat.x && player.x - player.width / 2 <= plat.x + plat.width) {
				// Find the closest platform vertically below the player
				var dy = player.y - plat.y;
				if (dy >= 0 && dy < minDist) {
					minDist = dy;
					lastFallenPlatformIndex = i;
				}
			}
		}
		// Find the nearest checkpoint at or before the fallen platform
		var checkpointToRespawn = 0;
		if (typeof checkpoints !== "undefined" && checkpoints.length) {
			var closestCheckpointIndex = -1;
			for (var i = 0; i < checkpoints.length; i++) {
				var checkpoint = checkpoints[i];
				if (checkpoint.platformIndex <= lastFallenPlatformIndex) {
					if (closestCheckpointIndex === -1 || checkpoint.platformIndex > checkpoints[closestCheckpointIndex].platformIndex) {
						closestCheckpointIndex = i;
					}
				}
			}
			if (closestCheckpointIndex !== -1) {
				checkpointToRespawn = checkpoints[closestCheckpointIndex].platformIndex;
				// Mark checkpoint as collected
				if (!checkpoints[closestCheckpointIndex].collected) {
					checkpoints[closestCheckpointIndex].collected = true;
					lastCheckpointIndex = checkpointToRespawn;
					checkpoints[closestCheckpointIndex].alpha = 0.5;
				}
			}
		}
		if (playerLives <= 0) {
			gameOver = true;
			LK.showGameOver();
			return;
		} else {
			// Respawn player at the nearest checkpoint (every 10th platform), or at the platform they fell from if no checkpoint reached
			if (typeof checkpointToRespawn !== "undefined" && checkpointToRespawn > 0 && checkpointToRespawn < platforms.length) {
				lastFallenPlatformIndex = checkpointToRespawn;
			}
			resetPlayer(true);
			// Optionally, move camera to player
			updateCamera();
			return;
		}
	}
	// Reached coffee house (win condition)
	if (coffeeHouse && intersectsAABB({
		x: player.x - player.width / 2,
		y: player.y - player.height,
		width: player.width,
		height: player.height
	}, {
		x: coffeeHouse.x - coffeeHouse.width / 2,
		y: coffeeHouse.y - coffeeHouse.height,
		width: coffeeHouse.width,
		height: coffeeHouse.height
	})) {
		LK.effects.flashScreen(0x00ff00, 1000);
		LK.setScore(score);
		// If on level 1, 2, 3, or 4, transition to next level
		if (typeof currentLevel === "undefined" || currentLevel === 1 || currentLevel === 2 || currentLevel === 3 || currentLevel === 4) {
			if (typeof showKiraathaneSection === "function") {
				showKiraathaneSection();
			} else {
				// Fallback: just pause the game and show a message overlay
				var overlay = new Text2("Kıraathaneye ulaştın!\nYeni bölüm geliyor...", {
					size: 120,
					fill: 0x222222,
					align: "center"
				});
				overlay.anchor.set(0.5, 0.5);
				overlay.x = 2048 / 2;
				overlay.y = 2732 / 2;
				LK.gui.center.addChild(overlay);
				gameOver = true;
			}
			return;
		}
	}
	// Win condition: player reaches the last platform
	// (Removed win condition when stepping on the last platform so the game does not end)
	// if (platforms.length > 0) {
	// var lastPlat = platforms[platforms.length - 1];
	// if (player.x + player.width / 2 >= lastPlat.x && player.x - player.width / 2 <= lastPlat.x + lastPlat.width && player.y >= lastPlat.y && player.y - player.height <= lastPlat.y + lastPlat.height) {
	// LK.effects.flashScreen(0x00ff00, 1000);
	// LK.setScore(score);
	// LK.showYouWin();
	// gameOver = true;
	// return;
	// }
	// }
};
// --- Game Start ---
// --- Fullscreen Cover Asset Before Game Start ---
// Show kebabBox fullscreen cover as the very first thing, before any other game asset
var fullscreenCoverAsset = LK.getAsset('kebabBox', {
	anchorX: 0,
	anchorY: 0,
	width: 2048,
	height: 2732
});
fullscreenCoverAsset.x = 0;
fullscreenCoverAsset.y = 0;
fullscreenCoverAsset.alpha = 1;
// Add kebabBox fullscreen cover as the last child, so it's always on top before game starts
game.addChild(fullscreenCoverAsset);
// Remove kebabBox fullscreen cover automatically after 5 seconds and start game
fullscreenCoverAsset.interactive = false;
LK.setTimeout(function () {
	if (fullscreenCoverAsset && typeof fullscreenCoverAsset.destroy === "function") {
		fullscreenCoverAsset.destroy();
		fullscreenCoverAsset = null;
		// Show GUI overlays again
		if (scoreTxt && typeof scoreTxt.visible !== "undefined") scoreTxt.visible = true;
		if (distTxt && typeof distTxt.visible !== "undefined") distTxt.visible = true;
		if (heartAssets && heartAssets.length) {
			for (var i = 0; i < heartAssets.length; i++) {
				if (heartAssets[i] && typeof heartAssets[i].visible !== "undefined") {
					heartAssets[i].visible = i < playerLives;
				}
			}
		}
	}
}, 5000);
// Always keep kebabBox on top by moving it to the last child after every frame
game._moveKebabBoxToTop = function () {
	if (fullscreenCoverAsset && game.children && game.children.length > 1) {
		// Remove kebabBox if not already last
		var idx = game.children.indexOf(fullscreenCoverAsset);
		if (idx !== -1 && idx !== game.children.length - 1) {
			game.children.splice(idx, 1);
			game.children.push(fullscreenCoverAsset);
		}
		// Also ensure boss health bar is always below kebabBox (if present)
		if (typeof bossHealthBarBg !== "undefined" && bossHealthBarBg && bossHealthBarBg.parent === game) {
			var barIdx = game.children.indexOf(bossHealthBarBg);
			if (barIdx !== -1 && barIdx > game.children.length - 2) {
				// Move bossHealthBarBg just before kebabBox
				game.children.splice(barIdx, 1);
				game.children.splice(game.children.length - 1, 0, bossHealthBarBg);
			}
		}
		if (typeof bossHealthBarFill !== "undefined" && bossHealthBarFill && bossHealthBarFill.parent === game) {
			var fillIdx = game.children.indexOf(bossHealthBarFill);
			if (fillIdx !== -1 && fillIdx > game.children.length - 2) {
				// Move bossHealthBarFill just before kebabBox
				game.children.splice(fillIdx, 1);
				game.children.splice(game.children.length - 1, 0, bossHealthBarFill);
			}
		}
	}
	// Move kebabBox fullscreen cover to the top of the GUI overlays as well
	// Remove kebabBox from any GUI overlay parents and re-add as last child
	if (fullscreenCoverAsset && fullscreenCoverAsset.parent && fullscreenCoverAsset.parent !== game) {
		try {
			if (fullscreenCoverAsset.parent && typeof fullscreenCoverAsset.parent.removeChild === "function") {
				fullscreenCoverAsset.parent.removeChild(fullscreenCoverAsset);
			}
		} catch (e) {}
		game.addChild(fullscreenCoverAsset);
	}
	// Hide or move score and distance text below kebabBox if kebabBox is visible
	if (fullscreenCoverAsset && fullscreenCoverAsset.alpha > 0.8) {
		if (scoreTxt && typeof scoreTxt.visible !== "undefined") scoreTxt.visible = false;
		if (distTxt && typeof distTxt.visible !== "undefined") distTxt.visible = false;
		// Hide hearts as well
		if (heartAssets && heartAssets.length) {
			for (var i = 0; i < heartAssets.length; i++) {
				if (heartAssets[i] && typeof heartAssets[i].visible !== "undefined") {
					heartAssets[i].visible = false;
				}
			}
		}
	} else {
		if (scoreTxt && typeof scoreTxt.visible !== "undefined") scoreTxt.visible = true;
		if (distTxt && typeof distTxt.visible !== "undefined") distTxt.visible = true;
		if (heartAssets && heartAssets.length) {
			for (var i = 0; i < heartAssets.length; i++) {
				if (heartAssets[i] && typeof heartAssets[i].visible !== "undefined") {
					heartAssets[i].visible = i < playerLives;
				}
			}
		}
	}
};
var _origUpdate = game.update;
game.update = function () {
	if (typeof game._moveKebabBoxToTop === "function") {
		game._moveKebabBoxToTop();
	}
	if (_origUpdate) return _origUpdate.apply(this, arguments);
};
function startGame() {
	score = 0;
	distance = 0;
	gameOver = false;
	playerLives = 3;
	scoreTxt.setText(score);
	distTxt.setText(distance + "m");
	// Reset level to 1 at game start
	currentLevel = 1;
	// Remove fullscreen cover after short delay (e.g. 1 second)
	LK.setTimeout(function () {
		if (fullscreenCoverAsset && typeof fullscreenCoverAsset.destroy === "function") {
			fullscreenCoverAsset.destroy();
			fullscreenCoverAsset = null;
		}
	}, 1000);
	// Reset enemies array and destroy old enemies if any
	if (typeof enemies !== "undefined" && enemies && enemies.length) {
		for (var i = 0; i < enemies.length; i++) {
			if (enemies[i] && typeof enemies[i].destroy === "function") {
				enemies[i].destroy();
			}
		}
	}
	enemies = [];
	// Reset checkpoints and lastCheckpointIndex
	checkpoints = [];
	lastCheckpointIndex = 0;
	createLevel();
	resetPlayer();
	updateHearts();
	// (hazard removed)
	// Remove hazards if any
	if (typeof hazards !== "undefined" && hazards.length) {
		for (var i = 0; i < hazards.length; i++) {
			if (hazards[i] && typeof hazards[i].destroy === "function") {
				hazards[i].destroy();
			}
		}
	}
	hazards = [];
	cameraX = 0;
	moveDir = 0;
	enemyStartDelay = 180; // 3 seconds at 60fps
}
// --- Start ---
startGame();
// Show new section/scene after reaching coffeehouse (placeholder, can be customized)
// Track current level globally (1-based)
if (typeof currentLevel === "undefined") {
	currentLevel = 1;
}
function showKiraathaneSection() {
	// Increase level up to 5
	if (typeof currentLevel === "undefined") {
		currentLevel = 1;
	}
	if (currentLevel < 5) {
		currentLevel++;
	}
	// Remove all game objects except GUI
	for (var i = 0; i < platforms.length; i++) {
		platforms[i].destroy();
	}
	for (var i = 0; i < coins.length; i++) {
		coins[i].destroy();
	}
	if (player) {
		player.destroy();
	}
	if (coffeeHouse) {
		coffeeHouse.destroy();
	}
	for (var i = 0; i < enemies.length; i++) {
		enemies[i].destroy();
	}
	for (var i = 0; i < bullets.length; i++) {
		bullets[i].destroy();
	}
	if (typeof boss !== "undefined" && boss) {
		boss.destroy();
		boss = null;
	}
	// Reset arrays
	platforms = [];
	coins = [];
	enemies = [];
	bullets = [];
	coffeeHouse = null;
	// Optionally, clear checkpoints for the new section
	checkpoints = [];
	lastCheckpointIndex = 0;
	// Remove hazards if any
	if (typeof hazards !== "undefined" && hazards.length) {
		for (var i = 0; i < hazards.length; i++) {
			if (hazards[i] && typeof hazards[i].destroy === "function") {
				hazards[i].destroy();
			}
		}
	}
	hazards = [];
	// Move camera to the start
	cameraX = 0;
	// Create a new set of platforms, coins, and coffeehouse (same as first section)
	createLevel();
	resetPlayer();
	// Reset game state for the new section
	gameOver = false;
	moveDir = 0;
	enemyStartDelay = 180; // 3 seconds at 60fps
	// Show overlay for transition, indicating level number with black background and white text
	var levelText = currentLevel + ". lvl";
	var overlayBg = LK.getAsset('centerCircle', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 900,
		height: 300,
		color: 0x000000
	});
	overlayBg.x = 2048 / 2;
	overlayBg.y = 2732 / 2;
	overlayBg.alpha = 0.85;
	LK.gui.center.addChild(overlayBg);
	var kiraathaneOverlay = new Text2(levelText, {
		size: 180,
		fill: 0xffffff,
		align: "center"
	});
	kiraathaneOverlay.anchor.set(0.5, 0.5);
	kiraathaneOverlay.x = 2048 / 2;
	kiraathaneOverlay.y = 2732 / 2;
	LK.gui.center.addChild(kiraathaneOverlay);
	// Remove overlay after 1.5 seconds
	LK.setTimeout(function () {
		kiraathaneOverlay.destroy();
		overlayBg.destroy();
	}, 1500);
}

===================================================================
--- original.js
+++ change.js
@@ -369,10 +369,10 @@
 
 /**** 
 * Game Code
 ****/ 
-// --- Bottom cloud is now fixed and does not teleport the player ---
 // --- Ava: Render bottomCloud at camera-relative position so it stays fixed like platforms ---
+// --- Bottom cloud is now fixed and does not teleport the player ---
 if (typeof bottomCloud !== "undefined" && bottomCloud && typeof bottomCloud.x === "number") {
 	bottomCloud.displayObject = bottomCloud.displayObject || bottomCloud;
 	bottomCloud.displayObject.x = bottomCloud.x - cameraX;
 	bottomCloud.displayObject.y = bottomCloud.y;
@@ -551,8 +551,23 @@
 		bottomCloud.destroy();
 	}
 	if (typeof currentLevel === "undefined" || currentLevel === 1) {
 		bottomCloud = new Platform();
+		if (bottomCloud.displayObject) {
+			// Replace the platform's asset with a special colored one
+			var specialAsset = LK.getAsset('bottomCloudSpecial', {
+				anchorX: 0,
+				anchorY: 0
+			});
+			// Remove the old asset if present
+			if (bottomCloud.children && bottomCloud.children.length > 0) {
+				bottomCloud.removeChild(bottomCloud.children[0]);
+			}
+			bottomCloud.addChild(specialAsset);
+			bottomCloud.displayObject = specialAsset;
+			bottomCloud.width = specialAsset.width;
+			bottomCloud.height = specialAsset.height;
+		}
 		bottomCloud.x = 2048 / 2 - bottomCloud.width / 2;
 		bottomCloud.y = 2732 - 120 - bottomCloud.height / 2;
 		// Add as a normal game object, not as a background
 		game.addChild(bottomCloud);