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

/**** 
* Classes
****/ 
// --- 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
****/ 
// blue coin, value 5
// purple coin, value 3
// gold coin, value 1
// Gold
// Neon
// Metal
// Ice
// Stone
// Night
// Candy
// Magic
// Mud
// Forest
// Grass
// was chipWhite
// was chipOrange
// was chipGreen
// was chipYellow
// was chipPurple
// was chipPink
// was chipCyan
// was chipBrown
// was chipBlack
// 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 coins = []; // All active coins
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('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
}];
// 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('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;
// --- Hide old score UI ---
var scoreTxt = {
	setText: function setText() {}
}; // dummy to avoid errors
var highScoreTxt = {
	setText: function setText() {}
}; // dummy to avoid errors
// --- 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);
	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;
	coinsCollected = 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;
		// (Jump animation now handled in platform collision logic)
		// 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;
		// Always play jump animation here for consistency
		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() {
					tween(pGfx, {
						scaleY: PLAYER_H / 320,
						scaleX: PLAYER_W / 320,
						rotation: 0,
						tint: 0xffffff
					}, {
						duration: 120
					});
				}
			});
		}
	} else {
		isJumping = true;
	}
	// --- 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;
		}
		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());
	// 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
@@ -276,8 +276,10 @@
 });
 // --- UI ---
 // Platform pass counter
 var platformsPassed = 0;
+// Track total coins collected
+var coinsCollected = 0;
 // --- Hide old score UI ---
 var scoreTxt = {
 	setText: function setText() {}
 }; // dummy to avoid errors