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

/**** 
* 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.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
****/ 
// Replace with actual asset id for fire icon
// Fire button: red circle with fire icon
// Replace with actual asset id for up arrow
// Jump button: yellow circle with up arrow
// Replace with actual asset id for right arrow
// Right button: green circle with right arrow
// Replace with actual asset id for left arrow
// Left button: blue circle with left arrow
// --- Control Button Assets ---
// Boss attack: fire projectile at player
// Unique boss asset
// New bullet figure asset (example: blue ellipse, unique id)
// Sun and cloud assets (example IDs, replace with real asset IDs as needed)
// --- Asset Initialization (shapes) ---
// Tween for animations (jump, enemy movement, etc)
// --- Game Variables ---
// Boss health bar assets
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);
	// --- 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;
	var numPlatforms = 10;
	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;
	// Add start platform at the very beginning
	var startPlat = new Platform();
	startPlat.x = 100;
	startPlat.y = 2000;
	platforms.push(startPlat);
	game.addChild(startPlat);
	// Place a coin above the start platform
	var startCoin = new Coin();
	startCoin.x = startPlat.x + startPlat.width / 2;
	startCoin.y = startPlat.y - 80;
	coins.push(startCoin);
	game.addChild(startCoin);
	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);
}
// --- 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 Buttons for Mobile UX ---
// Button sizes and positions
var BTN_SIZE = 260;
var BTN_MARGIN = 60;
var BTN_Y = 2732 - BTN_SIZE - 80;
// Left button (blue, with white left arrow)
var btnLeft = LK.getAsset('centerCircle', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: BTN_SIZE,
	height: BTN_SIZE,
	color: 0x3a7bd5
});
btnLeft.x = BTN_MARGIN + BTN_SIZE / 2;
btnLeft.y = BTN_Y;
btnLeft.alpha = 0.92;
btnLeft.displayObject = btnLeft;
LK.gui.bottom.addChild(btnLeft);
// Add left arrow icon
var leftArrow = new Text2("◀", {
	size: BTN_SIZE * 0.7,
	fill: 0xFFFFFF,
	align: "center"
});
leftArrow.anchor.set(0.5, 0.5);
leftArrow.x = btnLeft.x;
leftArrow.y = btnLeft.y;
leftArrow.alpha = 0.95;
LK.gui.bottom.addChild(leftArrow);
// Right button (green, with white right arrow)
var btnRight = LK.getAsset('centerCircle', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: BTN_SIZE,
	height: BTN_SIZE,
	color: 0x3ad57b
});
btnRight.x = BTN_MARGIN * 2 + BTN_SIZE * 1.5;
btnRight.y = BTN_Y;
btnRight.alpha = 0.92;
btnRight.displayObject = btnRight;
LK.gui.bottom.addChild(btnRight);
// Add right arrow icon
var rightArrow = new Text2("▶", {
	size: BTN_SIZE * 0.7,
	fill: 0xFFFFFF,
	align: "center"
});
rightArrow.anchor.set(0.5, 0.5);
rightArrow.x = btnRight.x;
rightArrow.y = btnRight.y;
rightArrow.alpha = 0.95;
LK.gui.bottom.addChild(rightArrow);
// Jump button (yellow, with up arrow)
var btnJump = LK.getAsset('centerCircle', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: BTN_SIZE,
	height: BTN_SIZE,
	color: 0xf7b731
});
btnJump.x = 2048 - BTN_MARGIN * 2 - BTN_SIZE * 1.5;
btnJump.y = BTN_Y;
btnJump.alpha = 0.92;
btnJump.displayObject = btnJump;
LK.gui.bottom.addChild(btnJump);
// Add up arrow icon
var upArrow = new Text2("▲", {
	size: BTN_SIZE * 0.7,
	fill: 0xFFFFFF,
	align: "center"
});
upArrow.anchor.set(0.5, 0.5);
upArrow.x = btnJump.x;
upArrow.y = btnJump.y;
upArrow.alpha = 0.95;
LK.gui.bottom.addChild(upArrow);
// Fire button (red, with fire emoji)
var btnFire = LK.getAsset('centerCircle', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: BTN_SIZE,
	height: BTN_SIZE,
	color: 0xd53343
});
btnFire.x = 2048 - BTN_MARGIN - BTN_SIZE / 2;
btnFire.y = BTN_Y;
btnFire.alpha = 0.92;
btnFire.displayObject = btnFire;
LK.gui.bottom.addChild(btnFire);
// Add fire icon
var fireIcon = new Text2("🔥", {
	size: BTN_SIZE * 0.6,
	fill: 0xFFFFFF,
	align: "center"
});
fireIcon.anchor.set(0.5, 0.5);
fireIcon.x = btnFire.x;
fireIcon.y = btnFire.y;
fireIcon.alpha = 0.95;
LK.gui.bottom.addChild(fireIcon);
// Add a subtle border to all buttons for visibility
function addBtnBorder(btn) {
	var border = LK.getAsset('centerCircle', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: BTN_SIZE + 16,
		height: BTN_SIZE + 16,
		color: 0xffffff
	});
	border.x = btn.x;
	border.y = btn.y;
	border.alpha = 0.18;
	LK.gui.bottom.addChild(border);
	// Move border below button in display list
	if (typeof LK.gui.bottom.setChildIndex === "function") {
		LK.gui.bottom.setChildIndex(border, 0);
	}
}
addBtnBorder(btnLeft);
addBtnBorder(btnRight);
addBtnBorder(btnJump);
addBtnBorder(btnFire);
// Button state
var moveDir = 0; // -1 = left, 1 = right, 0 = none
var _leftDown = false;
var _rightDown = false;
var _jumpDown = false;
var _fireDown = false;
// Helper: check if (x, y) is inside a button
function isInsideBtn(btn, x, y) {
	var dx = x - btn.x;
	var dy = y - btn.y;
	return dx * dx + dy * dy <= btn.width / 2 * (btn.width / 2);
}
// Touch down: check which button is pressed
game.down = function (x, y, obj) {
	if (gameOver) return;
	// Convert to GUI coordinates for buttons
	var guiX = x,
		guiY = y;
	// Left
	if (isInsideBtn(btnLeft, guiX, guiY)) {
		_leftDown = true;
		moveDir = -1;
	}
	// Right
	if (isInsideBtn(btnRight, guiX, guiY)) {
		_rightDown = true;
		moveDir = 1;
	}
	// Jump
	if (isInsideBtn(btnJump, guiX, guiY)) {
		_jumpDown = true;
		if (player.isOnGround) {
			player.jumpRequested = true;
		}
	}
	// Fire
	if (isInsideBtn(btnFire, guiX, guiY)) {
		_fireDown = true;
		// Fire straight, up, or down depending on vertical drag (if desired, here just straight)
		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 = true;
		bullets.push(bullet);
		game.addChild(bullet);
	}
	// If both left and right are pressed, prefer last pressed
	if (_leftDown && _rightDown) {
		moveDir = _rightDown ? 1 : -1;
	}
};
// Touch up: release buttons
game.up = function (x, y, obj) {
	var guiX = x,
		guiY = y;
	if (isInsideBtn(btnLeft, guiX, guiY)) {
		_leftDown = false;
		if (_rightDown) {
			moveDir = 1;
		} else {
			moveDir = 0;
		}
	}
	if (isInsideBtn(btnRight, guiX, guiY)) {
		_rightDown = false;
		if (_leftDown) {
			moveDir = -1;
		} else {
			moveDir = 0;
		}
	}
	if (isInsideBtn(btnJump, guiX, guiY)) {
		_jumpDown = false;
	}
	if (isInsideBtn(btnFire, guiX, guiY)) {
		_fireDown = false;
	}
	// If both released, stop
	if (!_leftDown && !_rightDown) {
		moveDir = 0;
	}
};
// Touch move: update button state if finger slides between buttons
game.move = function (x, y, obj) {
	var guiX = x,
		guiY = y;
	// Update left/right
	var wasLeft = _leftDown,
		wasRight = _rightDown;
	_leftDown = isInsideBtn(btnLeft, guiX, guiY);
	_rightDown = isInsideBtn(btnRight, guiX, guiY);
	if (_leftDown && !_rightDown) moveDir = -1;else if (_rightDown && !_leftDown) moveDir = 1;else moveDir = 0;
	// Jump
	_jumpDown = isInsideBtn(btnJump, guiX, guiY);
	// Fire
	_fireDown = isInsideBtn(btnFire, guiX, guiY);
};
// --- Game Update Loop ---
game.update = function () {
	if (gameOver) return;
	// --- Player Movement ---
	// Horizontal movement
	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;
		}
	}
	// --- 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;
						}
						// Show win overlay for defeating boss
						var bossWinOverlay = new Text2("Boss'u Yendin!", {
							size: 140,
							fill: 0xffffff,
							align: "center"
						});
						bossWinOverlay.anchor.set(0.5, 0.5);
						bossWinOverlay.x = 2048 / 2;
						bossWinOverlay.y = 2732 / 2;
						LK.gui.center.addChild(bossWinOverlay);
						LK.setTimeout(function () {
							bossWinOverlay.destroy();
						}, 1800);
					}
					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 ---
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;
	// 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
@@ -343,8 +343,17 @@
 
 /**** 
 * Game Code
 ****/ 
+// Replace with actual asset id for fire icon
+// Fire button: red circle with fire icon
+// Replace with actual asset id for up arrow
+// Jump button: yellow circle with up arrow
+// Replace with actual asset id for right arrow
+// Right button: green circle with right arrow
+// Replace with actual asset id for left arrow
+// Left button: blue circle with left arrow
+// --- Control Button Assets ---
 // Boss attack: fire projectile at player
 // Unique boss asset
 // New bullet figure asset (example: blue ellipse, unique id)
 // Sun and cloud assets (example IDs, replace with real asset IDs as needed)