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

/**** 
* Classes
****/ 
// --- Climber class ---
var Climber = Container.expand(function () {
	var self = Container.call(this);
	// Attach climber asset
	var climberSprite = self.attachAsset('climber', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// State
	self.wallSide = 0; // 0: left, 1: right
	self.isJumping = false;
	self.targetX = 0;
	self.vx = 0;
	self.vy = scrollSpeed;
	// Jump to the other wall
	self.jump = function () {
		// Determine target wall and X
		var nextWall = 1 - self.wallSide;
		var targetX = nextWall === 0 ? wallLeftX + wallWidth / 2 + climberWidth / 2 + 2 : wallRightX - wallWidth / 2 - climberWidth / 2 - 2;
		self.targetX = targetX;
		self.isJumping = true;
		self.wallSide = nextWall;
		// Animate jump with tween
		tween.to(self, {
			x: targetX
		}, 180, {
			easing: tween.Easing.Quadratic.Out,
			onComplete: function onComplete() {
				self.isJumping = false;
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// --- Constants ---
var wallWidth = 180;
var climberWidth = 120;
var climberHeight = 120;
// Make the gap between walls much narrower and ensure climber fits
var wallGap = 420;
var wallLeftX = (2048 - wallGap) / 2 - wallWidth / 2;
var wallRightX = (2048 + wallGap) / 2 + wallWidth / 2;
var playTopMargin = 100; // leave top 100px for menu
var playBottomMargin = 0;
// --- State ---
var climber;
var obstacles = [];
var bonuses = [];
var blueBonuses = [];
var distance = 0; // in pixels
var bonusScore = 0;
var scrollSpeed = 18; // initial vertical speed (pixels per tick) - increased for faster game
var speedIncreaseEvery = 400; // increase speed more frequently
var speedIncreaseAmount = 1.2; // increase speed more per step
var maxScrollSpeed = 48; // allow higher max speed
var lastObstacleY = 0;
var lastBonusY = 0;
var lastBlueBonusY = 0;
var obstacleSpacing = 420 * 1.1; // min vertical distance between obstacles, increased by 10%
var bonusSpacing = 900; // min vertical distance between bonuses
var blueBonusSpacing = 2000 * 10; // 2000m in px
var blueBonusActive = false;
var blueBonusTimer = 0;
var scoreTxt;
// --- Obstacle damage protection & opacity ---
var obstacleDamageEnabled = false;
var obstacleOpacity = 0.35; // Start with 35% opacity
// Set all current obstacles to given opacity
function setAllObstacleOpacity(alpha) {
	for (var i = 0; i < obstacles.length; i++) {
		if (obstacles[i] && obstacles[i].children && obstacles[i].children[0]) {
			obstacles[i].children[0].alpha = alpha;
		}
	}
}
// Set initial opacity
setAllObstacleOpacity(obstacleOpacity);
// At 1s: blink between 0.35 and 0.6 for 1s, then set to 0.6
LK.setTimeout(function () {
	var blinkCount = 0;
	var blinkInterval = LK.setInterval(function () {
		blinkCount++;
		// Alternate between 0.35 and 0.6 every 100ms
		obstacleOpacity = blinkCount % 2 === 0 ? 0.35 : 0.6;
		setAllObstacleOpacity(obstacleOpacity);
		if (blinkCount >= 10) {
			// 1s total (10 blinks)
			LK.clearInterval(blinkInterval);
			obstacleOpacity = 0.6;
			setAllObstacleOpacity(obstacleOpacity);
		}
	}, 100);
}, 1000);
// At 2s: set to 1.0 and enable damage
LK.setTimeout(function () {
	obstacleDamageEnabled = true;
	obstacleOpacity = 1.0;
	setAllObstacleOpacity(obstacleOpacity);
	// After 2s, always force obstacleOpacity to 1.0 for all future obstacles
	setAllObstacleOpacity = function setAllObstacleOpacity(alpha) {
		for (var i = 0; i < obstacles.length; i++) {
			if (obstacles[i] && obstacles[i].children && obstacles[i].children[0]) {
				obstacles[i].children[0].alpha = 1.0;
			}
		}
	};
}, 2000);
// --- Walls ---
// Walls removed: no wall graphics are added to the game
// --- Climber ---
climber = new Climber();
climber.x = wallLeftX + wallWidth / 2 + climberWidth / 2;
climber.y = 2732 / 2; // start at vertical center of the screen
game.addChild(climber);
// --- Score Display ---
scoreTxt = new Text2('0 m', {
	size: 120,
	fill: 0xFFF700
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// --- Helper: format distance ---
function formatDistance(px) {
	var meters = Math.floor(px / 10);
	if (meters < 1000) return meters + " m";
	return (meters / 1000).toFixed(2) + " km";
}
// --- Helper: update score text ---
function updateScoreText() {
	var meters = Math.floor(distance / 10);
	scoreTxt.setText(meters + " m");
}
// --- Helper: spawn obstacle ---
function spawnObstacle() {
	// Randomly pick left or right wall
	var side = Math.random() < 0.5 ? 0 : 1;
	var obs = new Obstacle();
	if (side === 0) {
		obs.x = wallLeftX + wallWidth / 2 + climberWidth / 2 + 2;
		obs.children[0].flipX = 1; // Mirror horizontally for left-side obstacles
	} else {
		obs.x = wallRightX - wallWidth / 2 - climberWidth / 2 - 2;
		obs.children[0].flipX = 0; // No flip for right-side obstacles
	}
	// Set opacity according to current global value
	if (obs.children && obs.children[0]) {
		// After 800m, always set to 1.0
		if (distance >= 8000) {
			obs.children[0].alpha = 1.0;
		} else {
			obs.children[0].alpha = obstacleOpacity;
		}
	}
	obs.y = lastObstacleY - obstacleSpacing - Math.random() * 220;
	obstacles.push(obs);
	game.addChild(obs);
	lastObstacleY = obs.y;
}
// --- Helper: spawn bonus ---
function spawnBonus() {
	var bonus = new Bonus();
	bonus.x = 2048 / 2;
	bonus.y = lastBonusY - bonusSpacing - Math.random() * 400;
	bonuses.push(bonus);
	game.addChild(bonus);
	lastBonusY = bonus.y;
}
// --- Helper: spawn blue bonus (every 2000m) ---
function spawnBlueBonus() {
	var blue = new BlueBonus();
	blue.x = 2048 / 2;
	blue.y = lastBlueBonusY - blueBonusSpacing;
	blueBonuses.push(blue);
	game.addChild(blue);
	lastBlueBonusY = blue.y;
}
// --- Initial obstacles/bonuses ---
// Start obstacles and bonuses from the bottom of the screen
lastObstacleY = 2732 - climberHeight / 2;
lastBonusY = 2732 - climberHeight / 2;
lastBlueBonusY = 2732 - climberHeight / 2;
// Spawn first blue bonus
spawnBlueBonus();
// Delay obstacle and bonus spawning by 1 second, then spawn at 2 second intervals
LK.setTimeout(function () {
	for (var i = 0; i < 6; i++) {
		spawnObstacle();
	}
	for (var i = 0; i < 2; i++) {
		spawnBonus();
	}
	// Set interval to spawn obstacles every 2 seconds (2000ms)
	LK.setInterval(function () {
		spawnObstacle();
	}, 2000);
}, 1000);
// --- Input: tap to jump ---
game.down = function (x, y, obj) {
	// Allow jump if not already moving to the same wall (ignore isJumping)
	var nextWall = 1 - climber.wallSide;
	// Only allow jump if not already moving to that wall
	if (!(climber.isJumping && climber.targetX === (nextWall === 0 ? wallLeftX + wallWidth / 2 + climberWidth / 2 + 2 : wallRightX - wallWidth / 2 - climberWidth / 2 - 2))) {
		climber.jump();
	}
};
// --- Move handler (not used for drag, but required by LK) ---
game.move = function (x, y, obj) {};
// --- Main update loop ---
game.update = function () {
	// Increase speed every 1000 meters (10,000 pixels)
	if (!game.lastSpeedMilestone) game.lastSpeedMilestone = 0;
	var metersNow = Math.floor(distance / 10);
	if (metersNow - game.lastSpeedMilestone >= 1000) {
		scrollSpeed *= 1.2;
		if (scrollSpeed > maxScrollSpeed) scrollSpeed = maxScrollSpeed;
		climber.vy = scrollSpeed;
		game.lastSpeedMilestone += 1000;
	}
	// Keep climber fixed at the vertical center of the screen, move obstacles/bonuses down by scrollSpeed
	var screenClimberY = 2732 / 2; // fixed Y position for climber at vertical center
	climber.y = screenClimberY;
	// Move all obstacles and bonuses down by scrollSpeed
	for (var i = 0; i < obstacles.length; i++) {
		obstacles[i].y += scrollSpeed;
		// After 800m (8000px), always force obstacle opacity to 1.0
		if (distance >= 8000 && obstacles[i].children && obstacles[i].children[0]) {
			obstacles[i].children[0].alpha = 1.0;
		}
	}
	for (var j = 0; j < bonuses.length; j++) {
		bonuses[j].y += scrollSpeed;
	}
	// Move blue bonuses down by scrollSpeed
	for (var j = 0; j < blueBonuses.length; j++) {
		blueBonuses[j].y += scrollSpeed;
	}
	// Spawn new blue bonus every 2000m (20000px)
	while (lastBlueBonusY > climber.y - 4000 * 2) {
		spawnBlueBonus();
	}
	// Walls removed: no wall movement needed
	// Update distance
	distance += scrollSpeed;
	updateScoreText();
	// Move obstacles and check collision
	for (var i = obstacles.length - 1; i >= 0; i--) {
		var obs = obstacles[i];
		// If obstacle goes off the bottom, move it back to the top with new random Y and side
		if (obs.y > 2732 + 100) {
			// Randomly pick left or right wall
			var side = Math.random() < 0.5 ? 0 : 1;
			if (side === 0) {
				obs.x = wallLeftX + wallWidth / 2 + climberWidth / 2 + 2;
				obs.children[0].flipX = 1; // Mirror horizontally for left-side obstacles
			} else {
				obs.x = wallRightX - wallWidth / 2 - climberWidth / 2 - 2;
				obs.children[0].flipX = 0; // No flip for right-side obstacles
			}
			// Set opacity according to current global value
			if (obs.children && obs.children[0]) {
				// After 800m, always set to 1.0
				if (distance >= 8000) {
					obs.children[0].alpha = 1.0;
				} else {
					obs.children[0].alpha = obstacleOpacity;
				}
			}
			// Place above the highest obstacle
			var highestY = climber.y - 400;
			for (var k = 0; k < obstacles.length; k++) {
				if (obstacles[k].y < highestY) highestY = obstacles[k].y;
			}
			obs.y = highestY - obstacleSpacing - Math.random() * 220;
			lastObstacleY = obs.y;
		}
		// Collision: only if climber is on same wall and overlaps in Y
		if (Math.abs(obs.x - climber.x) < climberWidth / 2 + 10 && Math.abs(obs.y - screenClimberY) < climberHeight / 2 + 30) {
			if (obstacleDamageEnabled) {
				LK.effects.flashScreen(0xff0000, 800);
				LK.showGameOver();
				return;
			}
		}
	}
	// Move bonuses and check collection
	for (var j = bonuses.length - 1; j >= 0; j--) {
		var b = bonuses[j];
		// If bonus goes off the bottom, move it back to the top (like obstacles)
		if (b.y > 2732 + 100) {
			// Place above the highest bonus
			var highestBonusY = climber.y - 800;
			for (var k = 0; k < bonuses.length; k++) {
				if (bonuses[k].y < highestBonusY) highestBonusY = bonuses[k].y;
			}
			b.y = highestBonusY - bonusSpacing - Math.random() * 400;
			lastBonusY = b.y;
			continue;
		}
		// Collect
		if (Math.abs(b.x - climber.x) < climberWidth / 2 + 40 && Math.abs(b.y - screenClimberY) < climberHeight / 2 + 40) {
			bonusScore += 10;
			updateScoreText();
			LK.effects.flashObject(b, 0xffff00, 400);
			// Move collected bonus to top (infinite)
			var highestBonusY = climber.y - 800;
			for (var k = 0; k < bonuses.length; k++) {
				if (bonuses[k].y < highestBonusY) highestBonusY = bonuses[k].y;
			}
			b.y = highestBonusY - bonusSpacing - Math.random() * 400;
			lastBonusY = b.y;
			continue;
		}
	}
	// Move blue bonuses and check collection
	for (var j = blueBonuses.length - 1; j >= 0; j--) {
		var bb = blueBonuses[j];
		// If blue bonus goes off the bottom, move it back to the top (like obstacles)
		if (bb.y > 2732 + 100) {
			var highestBlueY = climber.y - 2000;
			for (var k = 0; k < blueBonuses.length; k++) {
				if (blueBonuses[k].y < highestBlueY) highestBlueY = blueBonuses[k].y;
			}
			bb.y = highestBlueY - blueBonusSpacing;
			lastBlueBonusY = bb.y;
			continue;
		}
		// Collect blue bonus
		if (Math.abs(bb.x - climber.x) < climberWidth / 2 + 60 && Math.abs(bb.y - screenClimberY) < climberHeight / 2 + 60) {
			LK.effects.flashObject(bb, 0x3399ff, 400);
			// Move collected blue bonus to top (infinite)
			var highestBlueY = climber.y - 2000;
			for (var k = 0; k < blueBonuses.length; k++) {
				if (blueBonuses[k].y < highestBlueY) highestBlueY = blueBonuses[k].y;
			}
			bb.y = highestBlueY - blueBonusSpacing;
			lastBlueBonusY = bb.y;
			// Activate blue bonus effect
			blueBonusActive = true;
			blueBonusTimer = 300; // 5 seconds at 60fps
			// Set all obstacles to 50% opacity and disable damage
			for (var i = 0; i < obstacles.length; i++) {
				if (obstacles[i] && obstacles[i].children && obstacles[i].children[0]) {
					obstacles[i].children[0].alpha = 0.5;
				}
			}
			obstacleDamageEnabled = false;
			continue;
		}
	}
	// Spawn new obstacles/bonuses as needed for infinite runner
	while (lastObstacleY > climber.y - 1200) {
		spawnObstacle();
	}
	while (lastBonusY > climber.y - 1800) {
		spawnBonus();
	}
	// Handle blue bonus effect timer
	if (blueBonusActive) {
		blueBonusTimer--;
		if (blueBonusTimer <= 0) {
			blueBonusActive = false;
			obstacleDamageEnabled = true;
			// Restore all obstacles to full opacity (or 1.0 if after 2s/800m)
			for (var i = 0; i < obstacles.length; i++) {
				if (obstacles[i] && obstacles[i].children && obstacles[i].children[0]) {
					if (distance >= 8000) {
						obstacles[i].children[0].alpha = 1.0;
					} else {
						obstacles[i].children[0].alpha = 1.0;
					}
				}
			}
		}
	}
};
// --- Reset state on game over ---
game.on('gameover', function () {
	// All state will be reset by LK, so nothing to do here
});
// --- You win (not used in endless) ---
game.on('youwin', function () {
	// Not used
});

===================================================================
--- original.js
+++ change.js
@@ -3,8 +3,46 @@
 ****/ 
 var tween = LK.import("@upit/tween.v1");
 
 /**** 
+* Classes
+****/ 
+// --- Climber class ---
+var Climber = Container.expand(function () {
+	var self = Container.call(this);
+	// Attach climber asset
+	var climberSprite = self.attachAsset('climber', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	// State
+	self.wallSide = 0; // 0: left, 1: right
+	self.isJumping = false;
+	self.targetX = 0;
+	self.vx = 0;
+	self.vy = scrollSpeed;
+	// Jump to the other wall
+	self.jump = function () {
+		// Determine target wall and X
+		var nextWall = 1 - self.wallSide;
+		var targetX = nextWall === 0 ? wallLeftX + wallWidth / 2 + climberWidth / 2 + 2 : wallRightX - wallWidth / 2 - climberWidth / 2 - 2;
+		self.targetX = targetX;
+		self.isJumping = true;
+		self.wallSide = nextWall;
+		// Animate jump with tween
+		tween.to(self, {
+			x: targetX
+		}, 180, {
+			easing: tween.Easing.Quadratic.Out,
+			onComplete: function onComplete() {
+				self.isJumping = false;
+			}
+		});
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
 ****/ 
 var game = new LK.Game({
 	backgroundColor: 0x000000