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

/**** 
* Classes
****/ 
// Platform class
var Platform = Container.expand(function () {
	var self = Container.call(this);
	var plat = self.attachAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// For collision, store width/height
	self.width = plat.width;
	self.height = plat.height;
	return self;
});
// Player class
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGfx = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Physics
	self.vx = 0;
	self.vy = 0;
	self.isJumping = false;
	self.jumpPower = 68; // increased jump velocity for higher jumps
	self.movePower = 36; // increased horizontal velocity for farther jumps
	self.gravity = 2.2; // gravity per frame
	self.maxFall = 60; // max fall speed
	// For collision
	self.width = playerGfx.width;
	self.height = playerGfx.height;
	// Update method
	self.update = function () {
		// Apply gravity
		self.vy += self.gravity;
		if (self.vy > self.maxFall) self.vy = self.maxFall;
		// Move
		self.x += self.vx;
		self.y += self.vy;
		// Friction for horizontal movement
		self.vx *= 0.92;
		if (Math.abs(self.vx) < 0.2) self.vx = 0;
		// Prevent going off left/right
		if (self.x < self.width / 2) {
			self.x = self.width / 2;
			self.vx = 0;
		}
		if (self.x > 2048 - self.width / 2) {
			self.x = 2048 - self.width / 2;
			self.vx = 0;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
// Character: red box
// Platform: green box
var platforms = [];
var player;
var score = 0;
var scoreTxt;
var cameraY = 0; // how much the world is scrolled up
var platformSpacing = 220; // reduced vertical distance between platforms for easier jumps
var minPlatformX = 120;
var maxPlatformX = 2048 - 120;
var dragNode = null;
var lastHighestPlatformY = 0;
var gameOver = false;
// Score display
scoreTxt = new Text2('0', {
	size: 120,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Helper: create a platform at (x, y)
function createPlatform(x, y) {
	var plat = new Platform();
	plat.x = x;
	plat.y = y;
	platforms.push(plat);
	game.addChild(plat);
	return plat;
}
// Helper: find the platform the player is standing on (returns platform or null)
function getStandingPlatform() {
	for (var i = 0; i < platforms.length; ++i) {
		var plat = platforms[i];
		// Check if player is falling, and feet are just above platform
		var px = player.x;
		var py = player.y + player.height / 2;
		var left = plat.x - plat.width / 2;
		var right = plat.x + plat.width / 2;
		var top = plat.y - plat.height / 2;
		var bottom = plat.y + plat.height / 2;
		// Allow a little leeway for collision
		if (px > left + 10 && px < right - 10 && py > top - 10 && py < bottom + 10 && player.vy >= 0) {
			return plat;
		}
	}
	return null;
}
// Helper: remove platforms that are far below the camera
function cleanupPlatforms() {
	for (var i = platforms.length - 1; i >= 0; --i) {
		if (platforms[i].y - cameraY > 2732 + 200) {
			platforms[i].destroy();
			platforms.splice(i, 1);
		}
	}
}
// Helper: generate platforms above the highest one
function generatePlatforms() {
	// Find highest platform
	var highestY = 2732;
	for (var i = 0; i < platforms.length; ++i) {
		if (platforms[i].y < highestY) highestY = platforms[i].y;
	}
	// Generate up to fill above
	while (highestY > cameraY - 400) {
		var px = minPlatformX + Math.random() * (maxPlatformX - minPlatformX);
		highestY -= platformSpacing + (Math.random() - 0.5) * 80;
		createPlatform(px, highestY);
	}
}
// Helper: update score if player lands on a higher platform
function updateScore(plat) {
	if (plat && plat.y < lastHighestPlatformY) {
		score += 1;
		scoreTxt.setText(score);
		lastHighestPlatformY = plat.y;
	}
}
// Game start: setup player and initial platforms
function startGame() {
	// Reset
	for (var i = 0; i < platforms.length; ++i) platforms[i].destroy();
	platforms = [];
	score = 0;
	scoreTxt.setText(score);
	cameraY = 0;
	lastHighestPlatformY = 0;
	gameOver = false;
	// Create initial platforms
	var baseY = 2732 - 220;
	for (var i = 0; i < 8; ++i) {
		var px = 1024;
		if (i > 0) px = minPlatformX + Math.random() * (maxPlatformX - minPlatformX);
		var plat = createPlatform(px, baseY - i * platformSpacing);
		if (i === 0) lastHighestPlatformY = plat.y;
	}
	// Create player
	if (player) player.destroy();
	player = new Player();
	player.x = platforms[0].x;
	player.y = platforms[0].y - player.height / 2 - platforms[0].height / 2 - 2;
	player.vx = 0;
	player.vy = 0;
	game.addChild(player);
}
// Input: tap/click to jump
game.down = function (x, y, obj) {
	if (gameOver) return;
	// Convert to game coordinates
	var gx = x;
	var gy = y;
	// Only allow jump if not already jumping (i.e. standing on platform)
	var plat = getStandingPlatform();
	if (plat && player.vy >= 0) {
		// Direction: from player to tap
		var dx = gx - player.x;
		var dy = gy - player.y;
		// Only allow upward jumps
		if (dy < -40) {
			// Normalize
			var len = Math.sqrt(dx * dx + dy * dy);
			if (len < 1) len = 1;
			var nx = dx / len;
			var ny = dy / len;
			// Set velocity: bounce much higher for up, less for sideways, both exaggerated
			var jumpStrength;
			if (ny < -0.85) {
				// Strong upward tap: bounce much higher
				jumpStrength = player.jumpPower * 2.2;
				player.vx = nx * player.movePower * 0.7; // less sideways
			} else {
				// Sideways: bounce less, but still a lot
				jumpStrength = player.jumpPower * 1.2;
				player.vx = nx * player.movePower * 1.5; // more sideways
			}
			player.vy = ny * jumpStrength;
			player.isJumping = true;
		}
	}
};
// Camera follows player upward
function updateCamera() {
	// Camera follows player upward only
	var targetY = player.y - 900;
	if (targetY < cameraY) {
		cameraY = targetY;
	}
	// Clamp cameraY to 0 (bottom)
	if (cameraY > 0) cameraY = 0;
	// Move all game objects (except GUI) by -cameraY
	for (var i = 0; i < platforms.length; ++i) {
		platforms[i].yOnScreen = platforms[i].y - cameraY;
		platforms[i].y = platforms[i].yOnScreen;
	}
	if (player) {
		player.yOnScreen = player.y - cameraY;
		player.y = player.yOnScreen;
	}
}
// Main update loop
game.update = function () {
	if (gameOver) return;
	// Update player
	if (player) player.update();
	// Camera
	updateCamera();
	// Generate new platforms if needed
	generatePlatforms();
	// Remove old platforms
	cleanupPlatforms();
	// Check for landing on platform
	var plat = getStandingPlatform();
	if (plat && player.vy >= 0) {
		// Snap player to platform
		player.y = plat.y - plat.height / 2 - player.height / 2 - 2;
		// Add bounce: if falling fast, bounce up with a stronger effect (more bounce)
		if (player.vy > 10) {
			player.vy = -player.vy * 0.7; // bounce up, lose less energy for more bounce
			player.isJumping = true;
		} else {
			player.vy = 0;
			player.isJumping = false;
			updateScore(plat);
		}
	}
	// Game over: if player falls below bottom of screen
	if (player && player.y - cameraY > 2732 + 120) {
		gameOver = true;
		LK.effects.flashScreen(0xff0000, 800);
		LK.showGameOver();
	}
};
// Start game
startGame();

===================================================================
--- original.js
+++ change.js
@@ -69,11 +69,11 @@
 
 /**** 
 * Game Code
 ****/ 
-// Platform: green box
-// Character: red box
 // Game variables
+// Character: red box
+// Platform: green box
 var platforms = [];
 var player;
 var score = 0;
 var scoreTxt;
@@ -194,15 +194,19 @@
 			var len = Math.sqrt(dx * dx + dy * dy);
 			if (len < 1) len = 1;
 			var nx = dx / len;
 			var ny = dy / len;
-			// Set velocity, but limit jumpPower for strong upward jumps to avoid overshooting
-			var jumpStrength = player.jumpPower;
+			// Set velocity: bounce much higher for up, less for sideways, both exaggerated
+			var jumpStrength;
 			if (ny < -0.85) {
-				// If the tap is almost straight up, reduce jump power to avoid going too far
-				jumpStrength = player.jumpPower * 0.55;
+				// Strong upward tap: bounce much higher
+				jumpStrength = player.jumpPower * 2.2;
+				player.vx = nx * player.movePower * 0.7; // less sideways
+			} else {
+				// Sideways: bounce less, but still a lot
+				jumpStrength = player.jumpPower * 1.2;
+				player.vx = nx * player.movePower * 1.5; // more sideways
 			}
-			player.vx = nx * player.movePower;
 			player.vy = ny * jumpStrength;
 			player.isJumping = true;
 		}
 	}