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

/**** 
* Classes
****/ 
// 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
****/ 
// --- 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 // bright yellow on dark bg
}, {
	bg: 0x1e293b,
	platformAsset: 'chipGreen',
	platformColor: 0xf1f5f9 // white on blue bg
}];
// Helper to get current theme index based on score/level
function getThemeIndex(score) {
	return Math.floor(score / 100) % LEVEL_THEMES.length;
}
// 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;
// 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);
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 bigger and wider than the previous one
	// 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 w;
	if (typeof width === "number") {
		w = width;
	} else {
		// Each new platform is 4% wider than the previous, up to a max of 1100
		w = Math.min(prevW * 1.04, 1100);
	}
	// Determine theme based on current score (or maxHeight for new platforms)
	var score = Math.floor(maxHeight / 10) || 0;
	var theme = getCurrentTheme(score);
	var platformShapes = ['chipWhite', 'chipGreen'];
	// Change platform shape every 50 platforms
	var assetId = platformShapes[Math.floor(platforms.length / 50) % platformShapes.length];
	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);
	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 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
	var EASY_PLATFORM_W = 820;
	var EASY_PLATFORM_SPACING_MIN = 220;
	var EASY_PLATFORM_SPACING_MAX = 260;
	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 -= Math.random() * (EASY_PLATFORM_SPACING_MAX - EASY_PLATFORM_SPACING_MIN) + EASY_PLATFORM_SPACING_MIN;
	}
	// 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(LEVEL_THEMES[0].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 - PLATFORM_W / 2;
			var platRight = plat.x + PLATFORM_W / 2;
			// Check if player's feet are just above platform
			if (py >= platTop && py <= platTop + vy + 8) {
				if (px > platLeft && px < platRight) {
					return plat;
				}
			}
		}
	}
	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;
		// 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
	if (player.x < PLAYER_W / 2) player.x = PLAYER_W / 2;
	if (player.x > GAME_W - PLAYER_W / 2) player.x = GAME_W - PLAYER_W / 2;
	// 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) {
			platforms[i].destroy();
			platforms.splice(i, 1);
			platformsPassed++;
			scoreTxt.setText(platformsPassed.toString());
		}
	}
	// Add new platforms if needed
	while (platforms.length < 12) {
		var topY = platforms[0].y;
		// Use much easier spacing and width for new platforms
		var EASY_PLATFORM_W = 820;
		var EASY_PLATFORM_SPACING_MIN = 220;
		var EASY_PLATFORM_SPACING_MAX = 260;
		var newY = topY - Math.random() * (EASY_PLATFORM_SPACING_MAX - EASY_PLATFORM_SPACING_MIN) - EASY_PLATFORM_SPACING_MIN;
		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 maxHeight climbed
	var score = Math.floor(maxHeight / 10);
	scoreTxt.setText(score.toString());
	// Level theme logic removed
	// High score logic
	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
@@ -16,9 +16,9 @@
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
 	// For rotation handle
-	var handle = self.attachAsset('chipWhite', {
+	var handle = self.attachAsset('chipOrange', {
 		anchorX: 0.5,
 		anchorY: 0.5,
 		scaleX: 0.18,
 		scaleY: 0.18,
@@ -115,9 +115,9 @@
 // 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: 'caseRect',
+	platformAsset: 'chipWhite',
 	platformColor: 0xfacc15 // bright yellow on dark bg
 }, {
 	bg: 0x1e293b,
 	platformAsset: 'chipGreen',
@@ -131,9 +131,9 @@
 function getCurrentTheme(score) {
 	return LEVEL_THEMES[getThemeIndex(score)];
 }
 // Used for initial platform asset (will be replaced in createPlatform)
-var platformAsset = LK.getAsset('caseRect', {
+var platformAsset = LK.getAsset('chipWhite', {
 	anchorX: 0.5,
 	anchorY: 0.5,
 	scaleX: PLATFORM_W / 1100,
 	scaleY: PLATFORM_H / 700
@@ -174,9 +174,9 @@
 	}
 	// Determine theme based on current score (or maxHeight for new platforms)
 	var score = Math.floor(maxHeight / 10) || 0;
 	var theme = getCurrentTheme(score);
-	var platformShapes = ['caseRect', 'chipGreen'];
+	var platformShapes = ['chipWhite', 'chipGreen'];
 	// Change platform shape every 50 platforms
 	var assetId = platformShapes[Math.floor(platforms.length / 50) % platformShapes.length];
 	var platformColor = theme.platformColor;
 	// Get original asset size for aspect ratio