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

/**** 
* Classes
****/ 
// --- Coin class: collectible coin with value ---
var Coin = Container.expand(function () {
	var self = Container.call(this);
	// Randomly pick a coin type/value
	var coinTypes = [{
		asset: 'chipYellow',
		value: 1,
		color: 0xfacc15
	}, {
		asset: 'chipPink',
		value: 3,
		color: 0xdb8dc0
	}, {
		asset: 'chipCyan',
		value: 5,
		color: 0x1bd3dd
	}];
	var idx = typeof self.coinTypeIdx === "number" ? self.coinTypeIdx : Math.floor(Math.random() * coinTypes.length);
	var type = coinTypes[idx];
	self.value = type.value;
	self.assetId = type.asset;
	var coinGfx = self.attachAsset(self.assetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.28,
		scaleY: 0.28,
		color: type.color
	});
	// For collision
	self.radius = coinGfx.width / 2;
	// Track lastY for collision
	self.lastY = self.y;
	// Track if already collected
	self.collected = false;
	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('chipOrange', {
		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
****/ 
// Additional chip assets for more levels
// --- Icy Tower Constants ---
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
// --- State ---
var platforms = [];
var player = null;
var vy = 0;
var vx = 0;
var isJumping = false;
var isTouching = false;
var touchStartX = 0;
var cameraY = 0;
var maxHeight = 0;
var gameOver = false;
// --- Assets ---
var playerAsset = LK.getAsset('chipBlue', {
	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 = [{
	bg: 0x18181b,
	platformAsset: 'chipWhite',
	platformColor: 0xfacc15
},
// 1
{
	bg: 0x1e293b,
	platformAsset: 'chipGreen',
	platformColor: 0xf1f5f9
},
// 2
{
	bg: 0x3b1e1e,
	platformAsset: 'chipOrange',
	platformColor: 0xffffff
},
// 3
{
	bg: 0x2d1e3b,
	platformAsset: 'chipPurple',
	platformColor: 0xffe066
},
// 4
{
	bg: 0x3b2d1e,
	platformAsset: 'chipYellow',
	platformColor: 0x22223b
},
// 5
{
	bg: 0x1e3b2d,
	platformAsset: 'chipBlack',
	platformColor: 0xf8fafc
},
// 6
{
	bg: 0x3b1e2d,
	platformAsset: 'chipPink',
	platformColor: 0x22223b
},
// 7
{
	bg: 0x1e2d3b,
	platformAsset: 'chipCyan',
	platformColor: 0x22223b
},
// 8
{
	bg: 0x2d3b1e,
	platformAsset: 'chipBrown',
	platformColor: 0xf8fafc
},
// 9
{
	bg: 0x000000,
	platformAsset: 'chipBlue',
	platformColor: 0xfacc15
} // 10
];
// Helper to get current theme index based on platformsPassed/level
function getThemeIndex(score) {
	// Every level lasts for 20 platforms
	var idx = Math.floor(platformsPassed / 20);
	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('chipWhite', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: PLATFORM_W / 1100,
	scaleY: PLATFORM_H / 700
});
// --- UI ---
// Platform pass counter
var platformsPassed = 0;
// --- Coin state ---
var coins = [];
var coinScore = 0;
// Score text (platforms passed) - top right
var scoreTxt = new Text2('0', {
	size: 90,
	fill: 0xffffff
});
scoreTxt.anchor.set(1, 0); // right aligned
scoreTxt.x = GAME_W - 60;
scoreTxt.y = 60;
LK.gui.top.addChild(scoreTxt);
// Coin score text (top left, but not in menu area)
var coinScoreTxt = new Text2('Coins: 0', {
	size: 90,
	fill: 0xfacc15
});
coinScoreTxt.anchor.set(0, 0);
coinScoreTxt.x = 120; // leave 100px for menu
coinScoreTxt.y = 60;
LK.gui.top.addChild(coinScoreTxt);
var highScoreTxt = new Text2('Best: ' + highScore, {
	size: 60,
	fill: 0xfacc15
});
highScoreTxt.anchor.set(1, 0);
highScoreTxt.x = GAME_W - 60;
highScoreTxt.y = 160;
LK.gui.top.addChild(highScoreTxt);
// --- 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);
	// --- Add coin to platform (not first platform, and not every platform) ---
	if (typeof createPlatform.coinSeed === "undefined") createPlatform.coinSeed = 0;
	createPlatform.coinSeed++;
	if (platforms.length > 1 && createPlatform.coinSeed % 2 === 1) {
		// 50% chance, randomize coin type
		var coin = new Coin();
		// Place coin above platform, centered (relative to platform)
		coin.x = 0;
		coin.y = -PLATFORM_H / 2 - 50;
		// Randomize coin type for variety
		coin.coinTypeIdx = Math.floor(Math.random() * 3);
		// Re-apply asset for type
		var coinTypes = [{
			asset: 'chipYellow',
			value: 1,
			color: 0xfacc15
		}, {
			asset: 'chipPink',
			value: 3,
			color: 0xdb8dc0
		}, {
			asset: 'chipCyan',
			value: 5,
			color: 0x1bd3dd
		}];
		var type = coinTypes[coin.coinTypeIdx];
		coin.value = type.value;
		coin.assetId = type.asset;
		// Remove old child, add new asset
		if (coin.children.length > 0) coin.removeChild(coin.children[0]);
		var coinGfx = coin.attachAsset(coin.assetId, {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.28,
			scaleY: 0.28,
			color: type.color
		});
		coin.radius = coinGfx.width / 2;
		coin.collected = false;
		// Add coin as child of platform so it moves with platform
		plat.addChild(coin);
		// Store reference to parent platform for later removal
		coin.platform = plat;
		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 platforms
	for (var i = 0; i < platforms.length; ++i) {
		platforms[i].destroy();
	}
	platforms = [];
	// Remove old coins
	for (var i = 0; i < coins.length; ++i) {
		coins[i].destroy();
	}
	coins = [];
	coinScore = 0;
	if (typeof coinScoreTxt !== "undefined") coinScoreTxt.setText('Coins: 0');
	// Remove player
	if (player) player.destroy();
	// Create player
	player = new Container();
	var pGfx = player.attachAsset('chipBlue', {
		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);
	y -= 140; // Shorter spacing for first jump
	// 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;
	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;
	scoreTxt.setText('0');
	highScoreTxt.setText('Best: ' + highScore);
	// Reset theme and background
	game.lastThemeIndex = -1;
	game.setBackgroundColor(getCurrentTheme(platformsPassed).bg);
}
// --- 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;
	isTouching = true;
	touchStartX = x;
	// If player is on ground/platform, jump
	if (!isJumping) {
		vy = JUMP_VELOCITY;
		// Animate player: raise hands and change face (simulate with scale/rotation/tint)
		// Raise hands: scaleY shorter, scaleX wider, rotate slightly, tint happy color
		if (player && player.children && player.children.length > 0) {
			var pGfx = player.children[0];
			tween(pGfx, {
				scaleY: 0.7,
				scaleX: 1.2,
				rotation: 0.2,
				tint: 0x00e0ff
			}, {
				duration: 120,
				onFinish: function onFinish() {
					// Restore to normal after jump
					tween(pGfx, {
						scaleY: PLAYER_H / 320,
						scaleX: PLAYER_W / 320,
						rotation: 0,
						tint: 0xffffff
					}, {
						duration: 120
					});
				}
			});
		}
		// Direction: left or right half of screen
		if (x < GAME_W / 2) {
			vx = -MOVE_SPEED;
		} else {
			vx = MOVE_SPEED;
		}
		isJumping = true;
	}
};
game.up = function (x, y, obj) {
	isTouching = false;
	vx = 0;
};
game.move = function (x, y, obj) {
	// Optionally, allow swiping to control direction
	if (isTouching && !gameOver) {
		if (x < GAME_W / 2) {
			vx = -MOVE_SPEED;
		} else {
			vx = MOVE_SPEED;
		}
	}
};
// --- Main update loop ---
game.update = function () {
	if (gameOver) return;
	// Physics
	vy += GRAVITY;
	player.x += vx;
	player.y += vy;
	// 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;
				}
			});
		}
		// Double jump when hitting the wall
		vy = JUMP_VELOCITY * 2;
		isJumping = true;
	}
	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;
				}
			});
		}
		// Double jump when hitting the wall
		vy = JUMP_VELOCITY * 2;
		isJumping = true;
	}
	// Platform collision
	var plat = playerOnPlatform();
	if (plat && vy > 0) {
		player.y = plat.y - PLATFORM_H / 2;
		vy = JUMP_VELOCITY;
		isJumping = false;
	} else {
		isJumping = true;
	}
	// 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;
		}
		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 on this platform (within a small x/y range)
			for (var j = coins.length - 1; j >= 0; --j) {
				var coin = coins[j];
				// Coin is considered "on" the platform if its x is close and its y is just above the platform
				if (Math.abs(coin.x - platforms[i].x) < platforms[i].width / 2 + 10 && Math.abs(coin.y - (platforms[i].y - PLATFORM_H / 2 - 50)) < 60 && !coin.collected) {
					coin.destroy();
					coins.splice(j, 1);
				}
			}
			platforms[i].destroy();
			platforms.splice(i, 1);
			platformsPassed++;
			scoreTxt.setText(platformsPassed.toString());
		}
	}
	// --- Coin collection and cleanup ---
	for (var i = coins.length - 1; i >= 0; --i) {
		var coin = coins[i];
		// Remove coin if its platform is destroyed (platform not in platforms array)
		if (coin.platform && platforms.indexOf(coin.platform) === -1) {
			if (coin.parent) coin.destroy();
			coins.splice(i, 1);
			continue;
		}
		// Calculate coin's world position (since it's a child of platform)
		var coinWorld = coin.platform ? {
			x: coin.platform.x + coin.x,
			y: coin.platform.y + coin.y
		} : {
			x: coin.x,
			y: coin.y
		};
		// Remove coin if off screen
		if (coinWorld.y > GAME_H + 200) {
			if (coin.parent) coin.destroy();
			coins.splice(i, 1);
			continue;
		}
		// Check collision with player (circle-rect)
		if (!coin.collected) {
			var dx = player.x - coinWorld.x;
			var dy = player.y - PLAYER_H / 2 - coinWorld.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist < PLAYER_W * 0.5 + coin.radius * 0.7) {
				// Collect coin
				coin.collected = true;
				coinScore += coin.value;
				if (typeof coinScoreTxt !== "undefined") coinScoreTxt.setText('Coins: ' + coinScore);
				// Animate coin: scale up and fade out, then destroy
				var coinGfx = coin.children[0];
				(function (coin, i) {
					tween(coinGfx, {
						scaleX: coinGfx.scaleX * 1.7,
						scaleY: coinGfx.scaleY * 1.7,
						alpha: 0
					}, {
						duration: 220,
						onFinish: function onFinish() {
							if (coin && coin.parent) coin.destroy();
						}
					});
				})(coin, i);
				coins.splice(i, 1);
			}
		}
	}
	// 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());
	// Change background color if level changes
	var themeIndex = getThemeIndex(platformsPassed);
	if (game.lastThemeIndex !== themeIndex) {
		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;
		LK.setTimeout(function () {
			LK.showGameOver();
		}, 800);
	}
};
// --- Start game ---
resetGame();

===================================================================
--- original.js
+++ change.js
@@ -603,10 +603,19 @@
 	}
 	// --- Coin collection and cleanup ---
 	for (var i = coins.length - 1; i >= 0; --i) {
 		var coin = coins[i];
-		// Calculate coin's world position (since it's now a child of platform)
-		var coinWorld = coin.parent ? coin.parent.toGlobal(coin.position) : {
+		// Remove coin if its platform is destroyed (platform not in platforms array)
+		if (coin.platform && platforms.indexOf(coin.platform) === -1) {
+			if (coin.parent) coin.destroy();
+			coins.splice(i, 1);
+			continue;
+		}
+		// Calculate coin's world position (since it's a child of platform)
+		var coinWorld = coin.platform ? {
+			x: coin.platform.x + coin.x,
+			y: coin.platform.y + coin.y
+		} : {
 			x: coin.x,
 			y: coin.y
 		};
 		// Remove coin if off screen
@@ -614,14 +623,8 @@
 			if (coin.parent) coin.destroy();
 			coins.splice(i, 1);
 			continue;
 		}
-		// Remove coin if its platform is destroyed (platform not in platforms array)
-		if (coin.platform && platforms.indexOf(coin.platform) === -1) {
-			if (coin.parent) coin.destroy();
-			coins.splice(i, 1);
-			continue;
-		}
 		// Check collision with player (circle-rect)
 		if (!coin.collected) {
 			var dx = player.x - coinWorld.x;
 			var dy = player.y - PLAYER_H / 2 - coinWorld.y;