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

/**** 
* Classes
****/ 
// Cloud class: background only, moves with camera, not collidable
var Cloud = Container.expand(function () {
	var self = Container.call(this);
	// Pick a random cloud asset
	var cloudAssets = ['cloudBlue', 'cloudBright', 'cloudFluffy', 'cloudGray', 'cloudSoft'];
	var assetId = cloudAssets[Math.floor(Math.random() * cloudAssets.length)];
	var assetInfo = LK.getAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Scale clouds to a reasonable size for background
	var targetHeight = 180 + Math.random() * 80; // 180-260px
	var scale = targetHeight / assetInfo.height;
	var cloudGfx = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: scale,
		scaleY: scale,
		alpha: 0.45 + Math.random() * 0.15 // more transparent clouds
	});
	// Set initial position (x, y) and speed
	self.x = Math.random() * 2048;
	self.y = Math.random() * 2048;
	self.speedY = 0; // Will be set by camera movement
	// Give some clouds a gentle horizontal drift
	self.driftX = (Math.random() < 0.5 ? -1 : 1) * (0.2 + Math.random() * 0.5);
	// Clouds are always behind everything
	self.setToBack = function () {
		if (self.parent && self.parent.children.indexOf(self) > 0) {
			self.parent.setChildIndex(self, 0);
		}
	};
	// No collision, no input
	self.update = function () {
		// Horizontal drift
		self.x += self.driftX;
		// Wrap horizontally
		if (self.x < -cloudGfx.width / 2) self.x = 2048 + cloudGfx.width / 2;
		if (self.x > 2048 + cloudGfx.width / 2) self.x = -cloudGfx.width / 2;
		// Vertical movement is handled by camera diff in game.update
	};
	return self;
});
// --- Coin class: collectible, always same visual size, shows value popup ---
var Coin = Container.expand(function () {
	var self = Container.call(this);
	// Coin type: 1, 2, or 3 (for +1, +3, +5)
	self.coinType = 1;
	self.value = 1;
	self.assetId = 'chipCoin1';
	// Set asset and value based on type
	if (typeof arguments[0] === "number") {
		if (arguments[0] === 1) {
			self.coinType = 1;
			self.value = 1;
			self.assetId = 'chipCoin1';
		} else if (arguments[0] === 2) {
			self.coinType = 2;
			self.value = 3;
			self.assetId = 'chipCoin2';
		} else if (arguments[0] === 3) {
			self.coinType = 3;
			self.value = 5;
			self.assetId = 'chipCoin3';
		}
	}
	// Always render coins at the same visual size (height 80px)
	var targetHeight = 80;
	var assetInfo = LK.getAsset(self.assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var scale = targetHeight / assetInfo.height;
	var coinGfx = self.attachAsset(self.assetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: scale,
		scaleY: scale
	});
	// For collision
	self.radius = assetInfo.width * scale / 2;
	// Show value popup when collected
	self.showValuePopup = function () {
		var txt = new Text2('+' + self.value, {
			size: 60,
			fill: self.value === 1 ? "#ffe066" : self.value === 3 ? "#a78bfa" : "#38bdf8",
			font: "Impact"
		});
		txt.anchor.set(0.5, 0.5);
		txt.x = self.x;
		txt.y = self.y - 40;
		game.addChild(txt);
		// Ensure popup is above player
		if (txt.parent && player && txt.parent.children.indexOf(txt) < txt.parent.children.indexOf(player)) {
			txt.parent.setChildIndex(txt, txt.parent.children.length - 1);
		}
		tween(txt, {
			y: txt.y - 80,
			alpha: 0
		}, {
			duration: 700,
			onFinish: function onFinish() {
				txt.destroy();
			}
		});
	};
	return self;
});
// PokerChip class: draggable, rotatable, circular
var PokerChip = Container.expand(function () {
	var self = Container.call(this);
	// Asset id and color are passed in
	self.assetId = self.assetId || 'chipRed';
	var chip = self.attachAsset(self.assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// For rotation handle
	var handle = self.attachAsset('chipCoin1', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.18,
		scaleY: 0.18,
		y: -chip.height / 2 - 40
	});
	handle.alpha = 0.7;
	// For drag/rotate state
	self.isDragging = false;
	self.isRotating = false;
	self.dragOffsetX = 0;
	self.dragOffsetY = 0;
	self.startAngle = 0;
	self.startRotation = 0;
	// For hit testing
	self.radius = chip.width / 2;
	// Used to distinguish between drag and rotate
	self.down = function (x, y, obj) {
		var local = self.toLocal({
			x: x,
			y: y
		});
		// If touch is on handle, start rotating
		var dx = local.x - handle.x;
		var dy = local.y - handle.y;
		if (dx * dx + dy * dy < handle.width / 2 * (handle.width / 2)) {
			self.isRotating = true;
			// Angle from center to pointer
			var cx = self.x,
				cy = self.y;
			self.startAngle = Math.atan2(y - cy, x - cx);
			self.startRotation = self.rotation;
		} else {
			// Otherwise, start dragging
			self.isDragging = true;
			self.dragOffsetX = x - self.x;
			self.dragOffsetY = y - self.y;
		}
		// Bring to front
		if (self.parent) {
			self.parent.setChildIndex(self, self.parent.children.length - 1);
		}
	};
	self.up = function (x, y, obj) {
		self.isDragging = false;
		self.isRotating = false;
	};
	// No per-chip move handler; handled globally
	return self;
});

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

/**** 
* Game Code
****/ 
// Cloud shape assets for customizable cloud looks
// --- Icy Tower Constants ---
// Additional chip assets for more levels
// was chipBlack
// was chipBrown
// was chipCyan
// was chipPink
// was chipPurple
// was chipYellow
// was chipGreen
// was chipOrange
// was chipWhite
// Grass
// Forest
// Mud
// Magic
// Candy
// Night
// Stone
// Ice
// Metal
// Neon
// Gold
// gold coin, value 1
// purple coin, value 3
// (Cloud update and spawn logic removed)
var highScore = storage.highScore || 0;
var GAME_W = 2048;
var GAME_H = 2732;
var PLATFORM_W = 400;
var PLATFORM_H = 110;
var PLATFORM_SPACING_MIN = 320;
var PLATFORM_SPACING_MAX = 440;
var PLAYER_W = 120;
var PLAYER_H = 120;
var GRAVITY = 2.2;
var JUMP_VELOCITY = -48;
var MOVE_SPEED = 22;
var PLATFORM_X_MARGIN = 120;
var CAMERA_OFFSET = 900; // How far from bottom the player is kept
// --- Cloud background state ---
var clouds = [];
var NUM_CLOUDS = 8; // Number of clouds to show in background
// --- State ---
var platforms = [];
var coins = []; // All active coins
var player = null;
var vy = 0;
var vx = 0;
var isJumping = false;
var isTouching = false;
var touchStartX = 0;
// Track all active touches (for multi-touch)
var activeTouches = [];
var cameraY = 0;
var maxHeight = 0;
var gameOver = false;
game.hasDoubleJumped = false;
// --- Assets ---
var playerAsset = LK.getAsset('chipCharacter', {
	anchorX: 0.5,
	anchorY: 1,
	scaleX: PLAYER_W / 320,
	scaleY: PLAYER_H / 320
});
// Level themes: background color and platform asset per level
// Platform color is always high-contrast with background for visibility
var LEVEL_THEMES = [{
	// 1 Grass
	bg: 0x18181b,
	platformAsset: 'chipPlatform1',
	platformColor: 0xfacc15
}, {
	// 2 Forest
	bg: 0x1e293b,
	platformAsset: 'chipPlatform2',
	platformColor: 0xf1f5f9
}, {
	// 3 Mud
	bg: 0x3b1e1e,
	platformAsset: 'chipPlatform3',
	platformColor: 0xffffff
}, {
	// 4 Magic
	bg: 0x2d1e3b,
	platformAsset: 'chipPlatform4',
	platformColor: 0xffe066
}, {
	// 5 Candy
	bg: 0x3b2d1e,
	platformAsset: 'chipPlatform5',
	platformColor: 0x22223b
}, {
	// 6 Night
	bg: 0x1e3b2d,
	platformAsset: 'chipPlatform6',
	platformColor: 0xf8fafc
}, {
	// 7 Stone
	bg: 0x3b1e2d,
	platformAsset: 'chipPlatform7',
	platformColor: 0x22223b
}, {
	// 8 Ice
	bg: 0x1e2d3b,
	platformAsset: 'chipPlatform8',
	platformColor: 0x22223b
}, {
	// 9 Metal
	bg: 0x2d3b1e,
	platformAsset: 'chipPlatform9',
	platformColor: 0xf8fafc
}, {
	// 10 Neon
	bg: 0x000000,
	platformAsset: 'chipPlatform10',
	platformColor: 0xfacc15
}, {
	// 11 Special (chipPlatform11)
	bg: 0x22223b,
	platformAsset: 'chipPlatform11',
	platformColor: 0xffffff
}];
// Helper to get current theme index based on platformsPassed/level
function getThemeIndex(score) {
	// Every level lasts for 40 platforms
	var idx = Math.floor(platformsPassed / 40);
	if (idx < 0) idx = 0;
	if (idx >= LEVEL_THEMES.length) idx = LEVEL_THEMES.length - 1;
	return idx;
}
// Helper to get current theme object
function getCurrentTheme(score) {
	return LEVEL_THEMES[getThemeIndex(score)];
}
// Used for initial platform asset (will be replaced in createPlatform)
var platformAsset = LK.getAsset('chipPlatform8', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: PLATFORM_W / 1100,
	scaleY: PLATFORM_H / 700
});
// --- UI ---
// Platform pass counter
var platformsPassed = 0;
// Track total coins collected
var coinsCollected = 0;
// --- Score & Coins UI ---
// Create a container for the UI background and labels
var uiContainer = new Container();
// Add a black rectangle background behind the UI (covers full top width, rectangle shape)
var uiBgRect = LK.getAsset('uiTopBgRect', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0,
	scaleX: GAME_W / 100,
	scaleY: 1
});
uiContainer.addChild(uiBgRect);
var uiBgWidth = GAME_W;
var uiBgHeight = 110;
// "Coins: <number>" label (first, left)
var coinsLabelTxt = new Text2('Coins: 0', {
	size: 70,
	fill: 0xFFE066,
	font: "Impact"
});
coinsLabelTxt.anchor.set(0, 0.5); // left aligned, vertically centered
coinsLabelTxt.x = 60;
coinsLabelTxt.y = uiBgHeight / 2;
// "Score:" label (right of coins, with extra spacing)
var scoreLabelTxt = new Text2('Score:', {
	size: 70,
	fill: "#fff",
	font: "Impact"
});
scoreLabelTxt.anchor.set(0, 0.5); // left aligned, vertically centered
scoreLabelTxt.x = coinsLabelTxt.x + coinsLabelTxt.width + 80;
scoreLabelTxt.y = uiBgHeight / 2;
// Score value (right of label, with spacing)
var scoreTxt = new Text2('0', {
	size: 80,
	fill: "#fff",
	font: "Impact"
});
scoreTxt.anchor.set(0, 0.5); // left aligned, vertically centered
scoreTxt.x = scoreLabelTxt.x + scoreLabelTxt.width + 30;
scoreTxt.y = uiBgHeight / 2;
// Add all to container in new order: coins, score label, score value
uiContainer.addChild(coinsLabelTxt);
uiContainer.addChild(scoreLabelTxt);
uiContainer.addChild(scoreTxt);
// Center the UI container at the top of the screen
uiContainer.x = 0;
uiContainer.y = 0;
// Add to GUI overlay (top center)
LK.gui.top.addChild(uiContainer);
// Proper high score text object for updating best score
var highScoreTxt = new Text2('', {
	size: 60,
	fill: "#fff",
	font: "Impact"
});
highScoreTxt.anchor.set(1, 0.5); // right aligned, vertically centered
highScoreTxt.x = GAME_W - 60;
highScoreTxt.y = uiBgHeight / 2;
uiContainer.addChild(highScoreTxt);
// Listen for game over and update final score in the popup
LK.on('gameover', function () {
	// Show the correct final score in the game over popup
	if (typeof LK.setFinalScore === "function") {
		LK.setFinalScore(platformsPassed);
	}
});
// --- Helper: create a platform at (x, y) ---
function createPlatform(x, y, width) {
	var plat = new Container();
	// Make each new platform a bit harder as level increases
	// Find the last platform's width if any, otherwise use PLATFORM_W
	var lastPlat = platforms.length > 0 ? platforms[platforms.length - 1] : null;
	var prevW = lastPlat && lastPlat.width ? lastPlat.width : PLATFORM_W;
	var level = getThemeIndex(platformsPassed);
	// Platform width shrinks with level, min 220, max 1100
	// Make width decrease more gradually per level (every 20 platforms)
	var baseW = 820 - level * 40;
	if (baseW < 220) baseW = 220;
	var w;
	if (typeof width === "number") {
		w = width;
	} else {
		// Each new platform is 4% wider than the previous, but capped by baseW for the level
		w = Math.min(prevW * 1.04, baseW);
	}
	// Determine theme based on platformsPassed for new platforms
	var theme = getCurrentTheme(platformsPassed);
	var assetId = theme.platformAsset;
	var platformColor = theme.platformColor;
	// Get original asset size for aspect ratio
	var assetInfo = LK.getAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var origW = assetInfo.width;
	var origH = assetInfo.height;
	var scaleX = w / origW;
	var scaleY = PLATFORM_H / origH;
	// To preserve aspect ratio, use the smaller scale
	var scale = Math.min(scaleX, scaleY);
	var platGfx = plat.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: scale,
		scaleY: scale,
		color: platformColor
	});
	plat.x = x;
	plat.y = y;
	plat.width = w;
	plat.height = PLATFORM_H;
	plat.PLATFORM_H = PLATFORM_H;
	game.addChild(plat);
	platforms.push(plat);
	// --- Coin placement logic ---
	// Don't place coins on the first platform (player start)
	if (platforms.length > 1) {
		// 50% chance to spawn a coin on this platform
		if (Math.random() < 0.5) {
			// Randomly pick coin type: 60% +1, 30% +3, 10% +5
			var r = Math.random();
			var coinType = 1;
			if (r > 0.9) coinType = 3;else if (r > 0.6) coinType = 2;
			// Place coin at center of platform, slightly above
			var coin = new Coin(coinType);
			coin.x = plat.x;
			coin.y = plat.y - PLATFORM_H / 2 - 40;
			game.addChild(coin);
			coins.push(coin);
		}
	}
	return plat;
}
// --- Helper: find a safe X for a new platform, given previous platform ---
function getSafePlatformX(prevPlat, width) {
	// Always keep new platform horizontally reachable from previous
	var minX = Math.max(PLATFORM_X_MARGIN + width / 2, prevPlat ? prevPlat.x - 400 : PLATFORM_X_MARGIN + width / 2);
	var maxX = Math.min(GAME_W - PLATFORM_X_MARGIN - width / 2, prevPlat ? prevPlat.x + 400 : GAME_W - PLATFORM_X_MARGIN - width / 2);
	if (minX > maxX) minX = maxX = prevPlat ? prevPlat.x : GAME_W / 2;
	return minX + Math.random() * (maxX - minX);
}
// --- Helper: reset game state ---
function resetGame() {
	// Remove old coins
	for (var i = coins.length - 1; i >= 0; --i) {
		if (coins[i] && typeof coins[i].destroy === "function") {
			coins[i].destroy();
		}
	}
	coins = [];
	// Remove old platforms
	for (var i = 0; i < platforms.length; ++i) {
		platforms[i].destroy();
	}
	platforms = [];
	// Remove player
	if (player) player.destroy();
	// Create player
	player = new Container();
	var pGfx = player.attachAsset('chipCharacter', {
		anchorX: 0.5,
		anchorY: 1,
		scaleX: PLAYER_W / 320,
		scaleY: PLAYER_H / 320
	});
	player.x = GAME_W / 2;
	player.y = GAME_H - 400;
	player.width = PLAYER_W;
	player.height = PLAYER_H;
	game.addChild(player);
	vy = 0;
	vx = 0;
	isJumping = false;
	isTouching = false;
	cameraY = 0;
	maxHeight = 0;
	gameOver = false;
	// Create initial platforms
	var y = GAME_H - 200;
	// First platform: centered and wide, guaranteed under player
	var firstPlat = createPlatform(GAME_W / 2, y, 820);
	// Place player directly above first platform
	player.x = firstPlat.x;
	player.y = firstPlat.y - PLATFORM_H / 2 - PLAYER_H / 2 + 10; // Center player above platform, slightly above
	// Make platforms much wider and closer for easy jumps, but scale with level
	var level = getThemeIndex(platformsPassed);
	var EASY_PLATFORM_W = 820 - level * 40;
	if (EASY_PLATFORM_W < 220) EASY_PLATFORM_W = 220;
	// Keep vertical spacing constant for all levels
	var EASY_PLATFORM_SPACING = 240;
	var prevPlat = firstPlat;
	y -= EASY_PLATFORM_SPACING;
	for (var i = 1; i < 12; ++i) {
		var px = getSafePlatformX(prevPlat, EASY_PLATFORM_W);
		var plat = createPlatform(px, y, EASY_PLATFORM_W);
		prevPlat = plat;
		y -= EASY_PLATFORM_SPACING;
	}
	// Sort platforms by y
	platforms.sort(function (a, b) {
		return a.y - b.y;
	});
	// Score
	platformsPassed = 0;
	coinsCollected = 0;
	highScoreTxt.setText('Best: ' + highScore);
	// --- Background image logic ---
	if (typeof game.bgImage !== "undefined" && game.bgImage && typeof game.bgImage.destroy === "function") {
		game.bgImage.destroy();
	}
	game.bgImage = null;
	// Pick background image asset for current theme
	var themeIdx = getThemeIndex(platformsPassed);
	var bgImageIds = ['bgThemeGrass',
	// 0
	'bgThemeForest',
	// 1
	'bgThemeMud',
	// 2
	'bgThemeMagic',
	// 3
	'bgThemeCandy',
	// 4
	'bgThemeNight',
	// 5
	'bgThemeStone',
	// 6
	'bgThemeIce',
	// 7
	'bgThemeMetal',
	// 8
	'bgThemeNeon',
	// 9
	'bgThemeSpecial' // 10
	];
	var bgAssetId = bgImageIds[themeIdx] || 'bgThemeGrass';
	var bgAsset = LK.getAsset(bgAssetId, {
		anchorX: 0,
		anchorY: 0,
		x: 0,
		y: 0,
		scaleX: GAME_W / 2048,
		scaleY: GAME_H / 2732
	});
	game.bgImage = bgAsset;
	game.addChildAt(bgAsset, 0); // Always at back
	// Reset theme and background
	game.lastThemeIndex = -1;
	game.setBackgroundColor(getCurrentTheme(platformsPassed).bg);
	// Remove old clouds
	for (var i = clouds.length - 1; i >= 0; --i) {
		if (clouds[i] && typeof clouds[i].destroy === "function") {
			clouds[i].destroy();
		}
	}
	clouds = [];
	// Add new clouds to background, always above bgImage and below gameplay
	for (var i = 0; i < NUM_CLOUDS; ++i) {
		var cloud = new Cloud();
		// Distribute vertically in the upper 2/3 of the screen
		cloud.y = Math.random() * (GAME_H * 0.66);
		cloud.x = Math.random() * GAME_W;
		// Insert clouds just above bgImage (which is always at index 0)
		if (game.bgImage && typeof game.getChildIndex === "function") {
			// Insert at index 1, so clouds are above bgImage but below everything else
			game.addChildAt(cloud, 1);
		} else {
			game.addChild(cloud);
		}
		cloud.setToBack && cloud.setToBack();
		clouds.push(cloud);
	}
	// (Cloud background reset removed)
}
// --- Helper: check collision between player and platform ---
function playerOnPlatform() {
	for (var i = 0; i < platforms.length; ++i) {
		var plat = platforms[i];
		// Only check if player is falling
		if (vy >= 0) {
			var px = player.x;
			var py = player.y;
			var platTop = plat.y - (plat.PLATFORM_H ? plat.PLATFORM_H : PLATFORM_H) / 2;
			var platLeft = plat.x - plat.width / 2;
			var platRight = plat.x + plat.width / 2;
			// Use previous player y for more reliable collision
			if (typeof player.lastY === "undefined") player.lastY = py - vy;
			// Check if player's feet crossed the platform top this frame
			if (player.lastY <= platTop && py >= platTop) {
				// Require player to be horizontally within platform bounds (with a small margin)
				if (px > platLeft + 10 && px < platRight - 10) {
					player.lastY = py; // update for next frame
					return plat;
				}
			}
		}
	}
	if (typeof player !== "undefined") player.lastY = player.y;
	return null;
}
// --- Touch controls: left/right jump ---
game.down = function (x, y, obj) {
	if (gameOver) return;
	// Add this touch to activeTouches
	if (obj && obj.event && typeof obj.event.identifier !== "undefined") {
		// Remove if already present (shouldn't happen, but for safety)
		for (var i = 0; i < activeTouches.length; ++i) {
			if (activeTouches[i].id === obj.event.identifier) {
				activeTouches.splice(i, 1);
				break;
			}
		}
		activeTouches.push({
			id: obj.event.identifier,
			x: x,
			y: y
		});
	} else {
		// Fallback for mouse or single touch
		activeTouches = [{
			id: 0,
			x: x,
			y: y
		}];
	}
	isTouching = true;
	touchStartX = x;
	// Always use the last finger down for direction, even after double jump
	var lastTouch = activeTouches[activeTouches.length - 1];
	if (lastTouch && lastTouch.x < GAME_W / 2) {
		vx = -MOVE_SPEED;
	} else {
		vx = MOVE_SPEED;
	}
	// If player is on ground/platform, jump
	if (!isJumping && !game.hasDoubleJumped) {
		vy = JUMP_VELOCITY;
		isJumping = true;
	}
	// No-op: direction change after double jump is handled in move handler
};
game.up = function (x, y, obj) {
	// Remove this touch from activeTouches
	if (obj && obj.event && typeof obj.event.identifier !== "undefined") {
		for (var i = 0; i < activeTouches.length; ++i) {
			if (activeTouches[i].id === obj.event.identifier) {
				activeTouches.splice(i, 1);
				break;
			}
		}
	} else {
		// Fallback for mouse or single touch
		activeTouches = [];
	}
	if (activeTouches.length === 0) {
		isTouching = false;
		vx = 0;
	} else {
		// Use the new last finger for direction, even after double jump
		var lastTouch = activeTouches[activeTouches.length - 1];
		if (lastTouch && lastTouch.x < GAME_W / 2) {
			vx = -MOVE_SPEED;
		} else {
			vx = MOVE_SPEED;
		}
	}
};
game.move = function (x, y, obj) {
	// Update the position of the moving finger in activeTouches
	if (obj && obj.event && typeof obj.event.identifier !== "undefined") {
		for (var i = 0; i < activeTouches.length; ++i) {
			if (activeTouches[i].id === obj.event.identifier) {
				activeTouches[i].x = x;
				activeTouches[i].y = y;
				break;
			}
		}
	} else if (activeTouches.length > 0) {
		// Fallback for mouse or single touch
		activeTouches[activeTouches.length - 1].x = x;
		activeTouches[activeTouches.length - 1].y = y;
	}
	// Always use the last finger for direction, even after double jump or wall hit
	if (activeTouches.length > 0 && !gameOver) {
		var lastTouch = activeTouches[activeTouches.length - 1];
		if (lastTouch && lastTouch.x < GAME_W / 2) {
			vx = -MOVE_SPEED;
		} else {
			vx = MOVE_SPEED;
		}
	} else if (!isTouching) {
		vx = 0;
	}
	// No else: vx is always set while touching, even after double jump
};
// --- Main update loop ---
game.update = function () {
	if (gameOver) return;
	// Physics
	if (typeof player.lastVy === "undefined") player.lastVy = vy;
	if (typeof player.lastVx === "undefined") player.lastVx = vx;
	// Smooth velocity interpolation for mobile performance
	// Use a simple inertia/lerp for vx to avoid abrupt changes
	var targetVx = vx;
	if (typeof player.smoothVx === "undefined") player.smoothVx = vx;
	// Increase lerp factor for even smoother and more responsive movement
	player.smoothVx += (targetVx - player.smoothVx) * 0.32; // 0.32 is more responsive and smooth
	vy += GRAVITY;
	player.x += player.smoothVx;
	player.y += vy;
	player.lastVx = player.smoothVx;
	// Clamp player to screen and tumble on wall hit
	if (player.x < PLAYER_W / 2) {
		player.x = PLAYER_W / 2;
		// Tumble: rotate player quickly
		if (player && player.children && player.children.length > 0) {
			var pGfx = player.children[0];
			tween(pGfx, {
				rotation: pGfx.rotation - Math.PI * 2
			}, {
				duration: 400,
				onFinish: function onFinish() {
					pGfx.rotation = 0;
				}
			});
		}
		// Play shout sound when hitting left wall, with cooldown
		if (typeof game.lastShoutTime === "undefined") game.lastShoutTime = 0;
		var nowWall = Date.now();
		if (nowWall - game.lastShoutTime > 500) {
			// (shout sound now played only on successful double jump)
			// game.lastShoutTime = nowWall; // keep cooldown for future use if needed
			game.lastShoutTime = nowWall;
		}
		// Double jump when hitting the wall, but only if not already double jumped without release
		if (!game.hasDoubleJumped) {
			vy = JUMP_VELOCITY * 2;
			isJumping = true;
			game.hasDoubleJumped = true;
			// Play shout sound only if double jump is successful
			LK.getSound('shout').play();
		}
	}
	if (player.x > GAME_W - PLAYER_W / 2) {
		player.x = GAME_W - PLAYER_W / 2;
		// Tumble: rotate player quickly
		if (player && player.children && player.children.length > 0) {
			var pGfx = player.children[0];
			tween(pGfx, {
				rotation: pGfx.rotation + Math.PI * 2
			}, {
				duration: 400,
				onFinish: function onFinish() {
					pGfx.rotation = 0;
				}
			});
		}
		// Play shout sound when hitting right wall, with cooldown
		if (typeof game.lastShoutTime === "undefined") game.lastShoutTime = 0;
		var nowWall = Date.now();
		if (nowWall - game.lastShoutTime > 500) {
			// (shout sound now played only on successful double jump)
			// game.lastShoutTime = nowWall; // keep cooldown for future use if needed
			game.lastShoutTime = nowWall;
		}
		// Double jump when hitting the wall, but only if not already double jumped without release
		if (!game.hasDoubleJumped) {
			vy = JUMP_VELOCITY * 2;
			isJumping = true;
			game.hasDoubleJumped = true;
			// Play shout sound only if double jump is successful
			LK.getSound('shout').play();
		}
	}
	// Platform collision
	var plat = playerOnPlatform();
	if (plat && vy > 0) {
		player.y = plat.y - PLATFORM_H / 2;
		vy = JUMP_VELOCITY;
		isJumping = false;
		game.hasDoubleJumped = false; // Reset double jump lock only when landing
		// Always play jump animation here for consistency
		if (player && player.children && player.children.length > 0) {
			var pGfx = player.children[0];
			// Squash down, stretch wide, add a little rotation (no color change)
			tween(pGfx, {
				scaleY: 0.7,
				scaleX: 1.25,
				rotation: 0.18
			}, {
				duration: 90,
				onFinish: function onFinish() {
					// Stretch up, squash in, overshoot a bit for bounce
					tween(pGfx, {
						scaleY: 1.18 * PLAYER_H / 320,
						scaleX: 0.88 * PLAYER_W / 320,
						rotation: -0.08
					}, {
						duration: 90,
						onFinish: function onFinish() {
							// Return to normal
							tween(pGfx, {
								scaleY: PLAYER_H / 320,
								scaleX: PLAYER_W / 320,
								rotation: 0
							}, {
								duration: 90
							});
						}
					});
				}
			});
		}
	} else {
		isJumping = true;
		// No shout or fall sound here
	}
	// --- Coin collection ---
	for (var j = coins.length - 1; j >= 0; --j) {
		var coin = coins[j];
		// Simple circle collision
		var dx = player.x - coin.x;
		var dy = player.y - PLAYER_H / 2 - coin.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist < (PLAYER_W / 2 + coin.radius) * 0.7) {
			// Collect coin
			coin.showValuePopup();
			// Add to score (platformsPassed is main score, but we can show a popup)
			platformsPassed += coin.value;
			// Add to coins collected
			coinsCollected += coin.value;
			coins.splice(j, 1);
			coin.destroy();
		}
	}
	// Camera follows player upward
	if (player.y < GAME_H - CAMERA_OFFSET) {
		var diff = GAME_H - CAMERA_OFFSET - player.y;
		cameraY += diff;
		// Move all platforms and player down by diff
		for (var i = 0; i < platforms.length; ++i) {
			platforms[i].y += diff;
		}
		// Move all coins down by diff so they stay visually attached to their platform
		for (var i = 0; i < coins.length; ++i) {
			coins[i].y += diff;
		}
		// Move all clouds down by diff, and update their position
		for (var i = clouds.length - 1; i >= 0; --i) {
			var cloud = clouds[i];
			cloud.y += diff * 0.6; // Parallax: move slower than platforms for depth
			cloud.update && cloud.update();
			// Remove cloud if it goes off bottom, add new one at top
			if (cloud.y > GAME_H + 200) {
				cloud.destroy();
				clouds.splice(i, 1);
				// Add new cloud at top, always above bgImage
				var newCloud = new Cloud();
				newCloud.x = Math.random() * GAME_W;
				newCloud.y = -100 - Math.random() * 200;
				if (game.bgImage && typeof game.getChildIndex === "function") {
					// Insert at index 1, so clouds are above bgImage but below everything else
					game.addChildAt(newCloud, 1);
				} else {
					game.addChild(newCloud);
				}
				newCloud.setToBack && newCloud.setToBack();
				clouds.push(newCloud);
			}
		}
		player.y += diff;
		maxHeight += diff;
	}
	// Always keep player in front of platforms
	if (player.parent && player.parent.children.indexOf(player) !== player.parent.children.length - 1) {
		player.parent.setChildIndex(player, player.parent.children.length - 1);
	}
	// Remove platforms that are off screen, add new ones at top
	for (var i = platforms.length - 1; i >= 0; --i) {
		if (platforms[i].y > GAME_H + 100) {
			// Remove any coins that are visually on this platform (within platform width and just above it)
			for (var j = coins.length - 1; j >= 0; --j) {
				var coin = coins[j];
				// Coin is considered on this platform if its x is within platform width and y is just above platform
				if (coin.x >= platforms[i].x - platforms[i].width / 2 && coin.x <= platforms[i].x + platforms[i].width / 2 && Math.abs(coin.y - (platforms[i].y - PLATFORM_H / 2 - 40)) < 60) {
					coin.destroy();
					coins.splice(j, 1);
				}
			}
			platforms[i].destroy();
			platforms.splice(i, 1);
			// Only increment platformsPassed if not incremented by coin
			platformsPassed++;
		}
	}
	// Add new platforms if needed
	while (platforms.length < 12) {
		var topY = platforms[0].y;
		// Make platform width and spacing harder as level increases
		var level = getThemeIndex(platformsPassed);
		var EASY_PLATFORM_W = 820 - level * 40;
		if (EASY_PLATFORM_W < 220) EASY_PLATFORM_W = 220;
		// Keep vertical spacing constant for all levels
		var EASY_PLATFORM_SPACING = 240;
		var newY = topY - EASY_PLATFORM_SPACING;
		var prevPlat = platforms[0];
		var px = getSafePlatformX(prevPlat, EASY_PLATFORM_W);
		var plat = createPlatform(px, newY, EASY_PLATFORM_W);
		platforms.sort(function (a, b) {
			return a.y - b.y;
		});
	}
	// Score: based on platforms passed
	scoreTxt.setText(platformsPassed.toString());
	// Update coins label to show current coins collected
	coinsLabelTxt.setText('Coins: ' + coinsCollected);
	// Change background color and image if level changes
	var themeIndex = getThemeIndex(platformsPassed);
	if (game.lastThemeIndex !== themeIndex) {
		// Remove old background image
		if (typeof game.bgImage !== "undefined" && game.bgImage && typeof game.bgImage.destroy === "function") {
			game.bgImage.destroy();
		}
		// Add new background image for this theme
		var bgImageIds = ['bgThemeGrass',
		// 0
		'bgThemeForest',
		// 1
		'bgThemeMud',
		// 2
		'bgThemeMagic',
		// 3
		'bgThemeCandy',
		// 4
		'bgThemeNight',
		// 5
		'bgThemeStone',
		// 6
		'bgThemeIce',
		// 7
		'bgThemeMetal',
		// 8
		'bgThemeNeon',
		// 9
		'bgThemeSpecial' // 10
		];
		var bgAssetId = bgImageIds[themeIndex] || 'bgThemeGrass';
		var bgAsset = LK.getAsset(bgAssetId, {
			anchorX: 0,
			anchorY: 0,
			x: 0,
			y: 0,
			scaleX: GAME_W / 2048,
			scaleY: GAME_H / 2732
		});
		game.bgImage = bgAsset;
		game.addChildAt(bgAsset, 0); // Always at back
		game.setBackgroundColor(getCurrentTheme(platformsPassed).bg);
		game.lastThemeIndex = themeIndex;
	}
	// High score logic (still based on maxHeight climbed)
	var score = Math.floor(maxHeight / 10);
	if (score > highScore) {
		highScore = score;
		storage.highScore = highScore;
		highScoreTxt.setText('Best: ' + highScore);
	}
	// Game over: fall below screen
	if (player.y > GAME_H + 200) {
		gameOver = true;
		// Play fall sound when it's certain the player is going to die
		LK.getSound('fall').play();
		// Show game over after short delay
		LK.setTimeout(function () {
			LK.showGameOver();
		}, 1200);
	}
	// Update lastVy for next frame
	player.lastVy = vy;
	// Update clouds for horizontal drift (even if camera doesn't move)
	for (var i = 0; i < clouds.length; ++i) {
		if (clouds[i] && typeof clouds[i].update === "function") {
			clouds[i].update();
		}
	}
	// (Cloud update and spawn logic removed)
};
// --- Start game ---
resetGame();

===================================================================
--- original.js
+++ change.js
@@ -591,15 +591,21 @@
 			clouds[i].destroy();
 		}
 	}
 	clouds = [];
-	// Add new clouds to background
+	// Add new clouds to background, always above bgImage and below gameplay
 	for (var i = 0; i < NUM_CLOUDS; ++i) {
 		var cloud = new Cloud();
 		// Distribute vertically in the upper 2/3 of the screen
 		cloud.y = Math.random() * (GAME_H * 0.66);
 		cloud.x = Math.random() * GAME_W;
-		game.addChild(cloud);
+		// Insert clouds just above bgImage (which is always at index 0)
+		if (game.bgImage && typeof game.getChildIndex === "function") {
+			// Insert at index 1, so clouds are above bgImage but below everything else
+			game.addChildAt(cloud, 1);
+		} else {
+			game.addChild(cloud);
+		}
 		cloud.setToBack && cloud.setToBack();
 		clouds.push(cloud);
 	}
 	// (Cloud background reset removed)
@@ -885,13 +891,18 @@
 			// Remove cloud if it goes off bottom, add new one at top
 			if (cloud.y > GAME_H + 200) {
 				cloud.destroy();
 				clouds.splice(i, 1);
-				// Add new cloud at top
+				// Add new cloud at top, always above bgImage
 				var newCloud = new Cloud();
 				newCloud.x = Math.random() * GAME_W;
 				newCloud.y = -100 - Math.random() * 200;
-				game.addChild(newCloud);
+				if (game.bgImage && typeof game.getChildIndex === "function") {
+					// Insert at index 1, so clouds are above bgImage but below everything else
+					game.addChildAt(newCloud, 1);
+				} else {
+					game.addChild(newCloud);
+				}
 				newCloud.setToBack && newCloud.setToBack();
 				clouds.push(newCloud);
 			}
 		}