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

/**** 
* Classes
****/ 
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinGraphics = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.collected = false;
	// Gentle floating animation
	self.floatOffset = 0;
	self.originalY = 0;
	self.update = function () {
		if (!self.collected) {
			self.floatOffset += 0.1;
			self.y = self.originalY + Math.sin(self.floatOffset) * 5;
		}
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.speed = 1.5;
	self.direction = 1;
	self.verticalSpeed = 1;
	self.verticalDirection = 1;
	self.platformBounds = {
		left: 0,
		right: 500,
		top: 0,
		bottom: 0
	};
	self.assignedPlatform = 0;
	self.update = function () {
		// Horizontal movement
		self.x += self.speed * self.direction;
		// Bounce off platform edges horizontally
		if (self.x <= self.platformBounds.left || self.x >= self.platformBounds.right) {
			self.direction *= -1;
		}
		// Vertical movement within platform area
		self.y += self.verticalSpeed * self.verticalDirection;
		// Bounce off platform edges vertically
		if (self.y <= self.platformBounds.top || self.y >= self.platformBounds.bottom) {
			self.verticalDirection *= -1;
		}
	};
	return self;
});
var Ladder = Container.expand(function () {
	var self = Container.call(this);
	var ladderGraphics = self.attachAsset('ladder', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var Platform = Container.expand(function () {
	var self = Container.call(this);
	var platformGraphics = self.attachAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.speed = 4;
	self.climbSpeed = 3;
	self.isClimbing = false;
	self.currentPlatform = null;
	self.targetY = 0;
	self.update = function () {
		// Handle climbing movement
		if (self.isClimbing) {
			if (Math.abs(self.y - self.targetY) > 2) {
				if (self.y > self.targetY) {
					self.y -= self.climbSpeed;
				} else {
					self.y += self.climbSpeed;
				}
			} else {
				// Snap exactly to target platform position
				self.y = self.targetY;
				self.isClimbing = false;
				// Clear any movement flags to prevent continued movement
				moveUp = false;
				moveDown = false;
			}
		} else {
			// Check if player is at a ladder and should start climbing
			for (var i = 0; i < ladders.length; i++) {
				var ladder = ladders[i];
				if (Math.abs(self.x - ladder.x) < 50 && Math.abs(self.y - ladder.y) < 100) {
					// Player is at a ladder, determine which direction to climb
					var targetPlatformIndex = -1;
					var closestDistance = Infinity;
					// Find closest platform that's connected by this ladder
					for (var j = 0; j < platforms.length; j++) {
						if (Math.abs(platforms[j].x - ladder.x) < 100 && platforms[j].y !== self.y) {
							var distance = Math.abs(platforms[j].y - self.y);
							if (distance < closestDistance) {
								closestDistance = distance;
								targetPlatformIndex = j;
							}
						}
					}
					if (targetPlatformIndex !== -1) {
						self.isClimbing = true;
						self.x = ladder.x; // Snap to ladder
						self.targetY = platforms[targetPlatformIndex].y;
						self.currentPlatform = targetPlatformIndex;
						break;
					}
				}
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var currentLevel = 1;
var coinsCollected = 0;
var totalCoins = 5;
var platforms = [];
var ladders = [];
var coins = [];
var enemies = [];
var player;
// Platform positions (central hub + 4 outer platforms in 2x2 grid)
var platformPositions = [{
	x: 1024,
	y: 1366
},
// Center platform
{
	x: 524,
	y: 1066
},
// Top-left
{
	x: 1524,
	y: 1066
},
// Top-right
{
	x: 524,
	y: 1666
},
// Bottom-left
{
	x: 1524,
	y: 1666
} // Bottom-right
];
// Add background
var background = game.attachAsset('background1', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0
});
// Create platforms
for (var i = 0; i < platformPositions.length; i++) {
	var platform = new Platform();
	platform.x = platformPositions[i].x;
	platform.y = platformPositions[i].y;
	platforms.push(platform);
	game.addChild(platform);
}
// Create ladders connecting platforms
var ladderConnections = [{
	from: 0,
	to: 1
},
// Center to top-left
{
	from: 0,
	to: 2
},
// Center to top-right
{
	from: 0,
	to: 3
},
// Center to bottom-left
{
	from: 0,
	to: 4
} // Center to bottom-right
];
for (var i = 0; i < ladderConnections.length; i++) {
	var connection = ladderConnections[i];
	var fromPlatform = platforms[connection.from];
	var toPlatform = platforms[connection.to];
	var ladder = new Ladder();
	ladder.x = (fromPlatform.x + toPlatform.x) / 2;
	ladder.y = (fromPlatform.y + toPlatform.y) / 2;
	ladders.push(ladder);
	game.addChild(ladder);
}
// Create coins on each platform
for (var i = 0; i < platforms.length; i++) {
	var coin = new Coin();
	coin.x = platforms[i].x;
	coin.y = platforms[i].y - 50;
	coin.originalY = coin.y;
	coins.push(coin);
	game.addChild(coin);
}
// Create player
player = new Player();
player.x = platforms[0].x; // Start on center platform
player.y = platforms[0].y;
player.currentPlatform = 0;
game.addChild(player);
// Create enemies based on level
function spawnEnemies() {
	// Clear existing enemies
	for (var i = 0; i < enemies.length; i++) {
		enemies[i].destroy();
	}
	enemies = [];
	// Spawn exactly 4 enemies, one on each outer platform (excluding center platform at index 0)
	for (var i = 1; i < platforms.length; i++) {
		var enemy = new Enemy();
		enemy.x = platforms[i].x;
		enemy.y = platforms[i].y;
		enemy.assignedPlatform = i;
		// Set platform boundaries to keep enemy confined to its platform
		enemy.platformBounds.left = platforms[i].x - 250;
		enemy.platformBounds.right = platforms[i].x + 250;
		enemy.platformBounds.top = platforms[i].y - 100;
		enemy.platformBounds.bottom = platforms[i].y + 50;
		enemies.push(enemy);
		game.addChild(enemy);
	}
}
// Initial enemy spawn
spawnEnemies();
// Score display
var scoreText = new Text2('Coins: 0/' + totalCoins, {
	size: 60,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
// Level display
var levelText = new Text2('Level: ' + currentLevel, {
	size: 50,
	fill: 0xFFFFFF
});
levelText.anchor.set(1, 0);
LK.gui.topRight.addChild(levelText);
// Movement controls
var moveLeft = false;
var moveRight = false;
var moveUp = false;
var moveDown = false;
// Touch controls
game.down = function (x, y, obj) {
	// Use the x, y parameters directly as they are already in game coordinates
	var gamePos = {
		x: x,
		y: y
	};
	// Calculate distances for both horizontal and vertical movement
	var horizontalDistance = Math.abs(gamePos.x - player.x);
	var verticalDistance = Math.abs(gamePos.y - player.y);
	// Reset all movement flags first
	moveLeft = false;
	moveRight = false;
	moveUp = false;
	moveDown = false;
	// Check for ladder climbing first - if near ladder, only allow vertical movement
	var nearLadder = false;
	for (var i = 0; i < ladders.length; i++) {
		var ladder = ladders[i];
		if (Math.abs(gamePos.x - ladder.x) < 80 && Math.abs(gamePos.y - ladder.y) < 100) {
			nearLadder = true;
			// Only vertical movement when near ladder
			if (gamePos.y < player.y - 50) {
				moveUp = true;
			} else if (gamePos.y > player.y + 50) {
				moveDown = true;
			}
			break;
		}
	}
	// If not near ladder, prioritize the larger distance (horizontal vs vertical)
	if (!nearLadder) {
		if (horizontalDistance > verticalDistance) {
			// Horizontal movement takes priority
			if (gamePos.x < player.x - 50) {
				moveLeft = true;
			} else if (gamePos.x > player.x + 50) {
				moveRight = true;
			}
		} else {
			// Vertical movement takes priority
			if (gamePos.y < player.y - 50) {
				moveUp = true;
			} else if (gamePos.y > player.y + 50) {
				moveDown = true;
			}
		}
	}
};
game.up = function (x, y, obj) {
	moveLeft = false;
	moveRight = false;
	moveUp = false;
	moveDown = false;
};
// Game update loop
game.update = function () {
	// Handle player movement
	if (!player.isClimbing) {
		if (moveLeft) {
			player.x -= player.speed;
		}
		if (moveRight) {
			player.x += player.speed;
		}
		if (moveUp) {
			player.y -= player.speed;
		}
		if (moveDown) {
			player.y += player.speed;
		}
		// Keep player on current platform and within screen bounds
		if (player.currentPlatform !== null) {
			var currentPlatform = platforms[player.currentPlatform];
			player.x = Math.max(currentPlatform.x - 250, Math.min(currentPlatform.x + 250, player.x));
		}
		// Keep player within screen bounds
		player.x = Math.max(20, Math.min(2028, player.x));
		player.y = Math.max(100, Math.min(2632, player.y));
		// Additional check: if player is climbing and goes out of bounds, stop climbing
		if (player.isClimbing && (player.y <= 100 || player.y >= 2632)) {
			player.isClimbing = false;
			moveUp = false;
			moveDown = false;
			// Snap to nearest platform
			var nearestPlatform = platforms[0];
			var nearestDistance = Math.abs(player.y - nearestPlatform.y);
			for (var i = 1; i < platforms.length; i++) {
				var distance = Math.abs(player.y - platforms[i].y);
				if (distance < nearestDistance) {
					nearestDistance = distance;
					nearestPlatform = platforms[i];
					player.currentPlatform = i;
				}
			}
			player.y = nearestPlatform.y;
		}
		// Check for ladder climbing
		if (moveUp || moveDown) {
			for (var i = 0; i < ladders.length; i++) {
				var ladder = ladders[i];
				if (Math.abs(player.x - ladder.x) < 40) {
					player.isClimbing = true;
					player.x = ladder.x; // Snap to ladder
					// Find target platform
					var targetPlatformIndex = -1;
					if (moveUp) {
						// Find platform above
						for (var j = 0; j < platforms.length; j++) {
							if (platforms[j].y < player.y && Math.abs(platforms[j].x - ladder.x) < 100) {
								targetPlatformIndex = j;
								break;
							}
						}
					} else if (moveDown) {
						// Find platform below
						for (var j = 0; j < platforms.length; j++) {
							if (platforms[j].y > player.y && Math.abs(platforms[j].x - ladder.x) < 100) {
								targetPlatformIndex = j;
								break;
							}
						}
					}
					if (targetPlatformIndex !== -1) {
						player.targetY = platforms[targetPlatformIndex].y;
						player.currentPlatform = targetPlatformIndex;
					} else {
						// No valid platform found, stop climbing
						player.isClimbing = false;
						moveUp = false;
						moveDown = false;
					}
					break;
				}
			}
		}
	}
	// Check coin collection
	for (var i = 0; i < coins.length; i++) {
		var coin = coins[i];
		if (!coin.collected && player.intersects(coin)) {
			coin.collected = true;
			coin.alpha = 0;
			coinsCollected++;
			LK.setScore(coinsCollected);
			scoreText.setText('Coins: ' + coinsCollected + '/' + totalCoins);
			LK.getSound('coinCollect').play();
			// Check win condition
			if (coinsCollected >= totalCoins) {
				LK.showYouWin();
			}
		}
	}
	// Check enemy collisions
	for (var i = 0; i < enemies.length; i++) {
		var enemy = enemies[i];
		if (player.intersects(enemy)) {
			LK.getSound('enemyHit').play();
			LK.effects.flashScreen(0xff0000, 500);
			LK.showGameOver();
		}
	}
	// Level progression (spawn more enemies every 30 seconds)
	if (LK.ticks % (60 * 30) === 0 && coinsCollected < totalCoins) {
		currentLevel++;
		levelText.setText('Level: ' + currentLevel);
		spawnEnemies();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -288,36 +288,49 @@
 	var gamePos = {
 		x: x,
 		y: y
 	};
-	// Determine movement direction based on touch position relative to player
-	if (gamePos.x < player.x - 50) {
-		moveLeft = true;
-	} else if (gamePos.x > player.x + 50) {
-		moveRight = true;
-	}
-	// Check for vertical movement
-	if (gamePos.y < player.y - 50) {
-		moveUp = true;
-	} else if (gamePos.y > player.y + 50) {
-		moveDown = true;
-	}
-	// Check for ladder climbing - override vertical movement if near ladder
+	// Calculate distances for both horizontal and vertical movement
+	var horizontalDistance = Math.abs(gamePos.x - player.x);
+	var verticalDistance = Math.abs(gamePos.y - player.y);
+	// Reset all movement flags first
+	moveLeft = false;
+	moveRight = false;
+	moveUp = false;
+	moveDown = false;
+	// Check for ladder climbing first - if near ladder, only allow vertical movement
+	var nearLadder = false;
 	for (var i = 0; i < ladders.length; i++) {
 		var ladder = ladders[i];
 		if (Math.abs(gamePos.x - ladder.x) < 80 && Math.abs(gamePos.y - ladder.y) < 100) {
-			// Reset regular movement flags when near ladder
-			moveUp = false;
-			moveDown = false;
-			// Determine climb direction
-			if (gamePos.y < player.y) {
+			nearLadder = true;
+			// Only vertical movement when near ladder
+			if (gamePos.y < player.y - 50) {
 				moveUp = true;
-			} else {
+			} else if (gamePos.y > player.y + 50) {
 				moveDown = true;
 			}
 			break;
 		}
 	}
+	// If not near ladder, prioritize the larger distance (horizontal vs vertical)
+	if (!nearLadder) {
+		if (horizontalDistance > verticalDistance) {
+			// Horizontal movement takes priority
+			if (gamePos.x < player.x - 50) {
+				moveLeft = true;
+			} else if (gamePos.x > player.x + 50) {
+				moveRight = true;
+			}
+		} else {
+			// Vertical movement takes priority
+			if (gamePos.y < player.y - 50) {
+				moveUp = true;
+			} else if (gamePos.y > player.y + 50) {
+				moveDown = true;
+			}
+		}
+	}
 };
 game.up = function (x, y, obj) {
 	moveLeft = false;
 	moveRight = false;