/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	highScore: 0,
	gearCollected: 0,
	gearUpgrades: {
		oxygenEfficiency: 0,
		climbingSpeed: 0,
		weatherResistance: 0
	}
});

/**** 
* Classes
****/ 
var Campsite = Container.expand(function () {
	var self = Container.call(this);
	var campsiteGraphics = self.attachAsset('campsite', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = campsiteGraphics.width;
	self.height = campsiteGraphics.height;
	self.active = true;
	return self;
});
var Climber = Container.expand(function () {
	var self = Container.call(this);
	var climberGraphics = self.attachAsset('climber', {
		anchorX: 2,
		anchorY: 2
	});
	self.width = climberGraphics.width;
	self.height = climberGraphics.height;
	self.vx = 0;
	self.vy = 0;
	self.speed = 12 + storage.gearUpgrades.climbingSpeed * 2;
	self.jumpPower = -25;
	self.gravity = 0;
	self.onGround = false;
	self.climbing = false;
	self.targetX = null;
	self.targetY = null;
	self.movingToTarget = false;
	self.lastX = 0;
	self.lastY = 0;
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		if (self.movingToTarget && self.targetX !== null) {
			var dx = self.targetX - self.x;
			var dy = self.targetY - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > self.speed) {
				var angle = Math.atan2(dy, dx);
				self.vx = Math.cos(angle) * self.speed;
				self.vy = Math.sin(angle) * self.speed;
			} else {
				self.x = self.targetX;
				self.y = self.targetY;
				self.vx = 0;
				self.vy = 0;
				self.movingToTarget = false;
				self.targetX = null;
				self.targetY = null;
			}
		}
		if (!self.climbing && !self.movingToTarget) {
			self.vy += self.gravity;
		}
		self.x += self.vx;
		self.y += self.vy;
		// Constrain to screen bounds
		if (self.x < self.width / 2) {
			self.x = self.width / 2;
			self.vx = 0;
		} else if (self.x > 2048 - self.width / 2) {
			self.x = 2048 - self.width / 2;
			self.vx = 0;
		}
	};
	self.jump = function () {
		if (self.onGround) {
			self.vy = self.jumpPower;
			self.onGround = false;
			LK.getSound('jump').play();
		}
	};
	self.moveToPosition = function (x, y) {
		self.targetX = x;
		self.targetY = y;
		self.movingToTarget = true;
		self.climbing = true;
	};
	return self;
});
var ClimbingPath = Container.expand(function (pathType) {
	var self = Container.call(this);
	// Different path types: 'normal', 'narrow', 'slippery'
	self.pathType = pathType || 'normal';
	var pathWidth = 300;
	var pathColor = 0xDDDDDD;
	if (self.pathType === 'narrow') {
		pathWidth = 150;
		pathColor = 0xBBBBBB;
	} else if (self.pathType === 'slippery') {
		pathWidth = 250;
		pathColor = 0xADD8E6;
	}
	var pathGraphics = self.attachAsset('path', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: pathWidth,
		height: 100,
		tint: pathColor
	});
	self.width = pathGraphics.width;
	self.height = pathGraphics.height;
	return self;
});
var Collectable = Container.expand(function (collectableType) {
	var self = Container.call(this);
	self.collectableType = collectableType || 'oxygen';
	var assetId, value;
	if (self.collectableType === 'oxygen') {
		assetId = 'oxygen';
		value = 20 + Math.floor(Math.random() * 10);
	} else if (self.collectableType === 'gear') {
		assetId = 'gear';
		value = 1;
	}
	var collectableGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = collectableGraphics.width;
	self.height = collectableGraphics.height;
	self.value = value;
	self.active = true;
	self.update = function () {
		// Simple hover animation
		collectableGraphics.y = Math.sin(LK.ticks / 20) * 5;
	};
	return self;
});
var Hazard = Container.expand(function (hazardType) {
	var self = Container.call(this);
	self.hazardType = hazardType || 'rock';
	var assetId, size, speed;
	if (self.hazardType === 'rock') {
		assetId = 'rock';
		size = 100;
		speed = 5 + Math.random() * 3;
	} else if (self.hazardType === 'snowball') {
		assetId = 'snowball';
		size = 90;
		speed = 7 + Math.random() * 4;
	} else if (self.hazardType === 'gap') {
		assetId = 'deadlyGap';
		size = 300;
		speed = 0;
	}
	var hazardGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = hazardGraphics.width;
	self.height = hazardGraphics.height;
	self.vy = speed;
	self.active = true;
	self.update = function () {
		if (self.hazardType !== 'gap') {
			self.y += self.vy;
		}
		// Remove when out of screen
		if (self.y > 2732 + self.height) {
			self.active = false;
		}
	};
	return self;
});
var Mountain = Container.expand(function () {
	var self = Container.call(this);
	var mountainGraphics = self.attachAsset('mountain', {
		anchorX: 0.5,
		anchorY: 0
	});
	self.width = mountainGraphics.width;
	self.height = mountainGraphics.height;
	return self;
});
var OxygenBar = Container.expand(function () {
	var self = Container.call(this);
	var barBackground = self.attachAsset('oxygenBarBg', {
		anchorX: 0,
		anchorY: 0.5
	});
	var bar = self.attachAsset('oxygenBar', {
		anchorX: 0,
		anchorY: 0.5,
		x: 5,
		y: 0
	});
	var oxygenText = new Text2('OXYGEN', {
		size: 30,
		fill: 0xFFFFFF
	});
	oxygenText.anchor.set(0.5, 0.5);
	oxygenText.x = 200;
	oxygenText.y = 0;
	self.addChild(oxygenText);
	self.maxWidth = bar.width;
	self.updateBar = function (percentage) {
		// Clamp percentage between 0 and 100
		percentage = Math.max(0, Math.min(100, percentage));
		bar.width = self.maxWidth * (percentage / 100);
		// Change color based on oxygen level
		if (percentage > 60) {
			bar.tint = 0x00BFFF; // Blue
		} else if (percentage > 30) {
			bar.tint = 0xFFAA00; // Orange
		} else {
			bar.tint = 0xFF0000; // Red
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state
var gameActive = true;
var score = 0;
var altitude = 0;
var oxygen = 100;
var maxOxygen = 100;
var oxygenUseRate = 0.1 - storage.gearUpgrades.oxygenEfficiency * 0.01;
var weatherEffect = 0;
var weatherResistance = storage.gearUpgrades.weatherResistance;
var level = 1;
var levelHeight = 5000;
// Screen scroll
var scrollSpeed = 2;
var camera = {
	y: 0
};
// Game elements
var climber;
var paths = [];
var hazards = [];
var collectables = [];
var campsites = [];
var mountains = [];
var nextPathY = 2600; // Start position for first path
var pathGap = 220; // Gap between consecutive paths
// UI elements
var scoreText;
var altitudeText;
var levelText;
var oxygenBar;
// Setup game
function setupGame() {
	// Create UI
	setupUI();
	// Create mountains
	createMountains();
	// Create initial paths
	for (var i = 0; i < 15; i++) {
		createPathAt(nextPathY);
		nextPathY -= pathGap;
	}
	// Create climber
	climber = new Climber();
	climber.x = 2048 / 2;
	climber.y = 2400;
	game.addChild(climber);
	// Start background music
	LK.playMusic('bgMusic', {
		fade: {
			start: 0,
			end: 0.3,
			duration: 1000
		}
	});
}
function setupUI() {
	// Score text
	scoreText = new Text2('SCORE: 0', {
		size: 50,
		fill: 0xFFFFFF
	});
	scoreText.anchor.set(1, 0);
	LK.gui.topRight.addChild(scoreText);
	// Altitude text
	altitudeText = new Text2('ALTITUDE: 0 M', {
		size: 50,
		fill: 0xFFFFFF
	});
	altitudeText.anchor.set(0.5, 0);
	LK.gui.top.addChild(altitudeText);
	// Level text
	levelText = new Text2('LEVEL: 1', {
		size: 50,
		fill: 0xFFFFFF
	});
	levelText.anchor.set(0, 0);
	LK.gui.topLeft.addChild(levelText);
	levelText.x = 120; // Offset from the top left corner to avoid UI elements
	// Oxygen bar
	oxygenBar = new OxygenBar();
	oxygenBar.x = 200;
	oxygenBar.y = 100;
	LK.gui.top.addChild(oxygenBar);
}
function createMountains() {
	// Create two mountains for parallax effect
	var mountain1 = new Mountain();
	mountain1.x = 2048 / 2;
	mountain1.y = 2200;
	mountains.push(mountain1);
	game.addChild(mountain1);
	var mountain2 = new Mountain();
	mountain2.x = 2048 / 2;
	mountain2.y = 700;
	mountains.push(mountain2);
	game.addChild(mountain2);
}
function createPathAt(yPosition) {
	// Random path properties
	var pathX = Math.random() * (2048 - 400) + 200;
	var pathType = 'normal';
	var pathTypeRoll = Math.random();
	if (pathTypeRoll > 0.7) {
		pathType = 'narrow';
	} else if (pathTypeRoll > 0.5) {
		pathType = 'slippery';
	}
	// Create the path
	var path = new ClimbingPath(pathType);
	path.x = pathX;
	path.y = yPosition;
	paths.push(path);
	game.addChild(path);
	// Chance to add collectable
	if (Math.random() > 0.6) {
		var collectableType = Math.random() > 0.7 ? 'gear' : 'oxygen';
		var collectable = new Collectable(collectableType);
		collectable.x = pathX + (Math.random() * 200 - 100);
		collectable.y = yPosition - 80;
		collectables.push(collectable);
		game.addChild(collectable);
	}
	// Lower chance to add campsite
	if (Math.random() > 0.9) {
		var campsite = new Campsite();
		campsite.x = pathX;
		campsite.y = yPosition - 80;
		campsites.push(campsite);
		game.addChild(campsite);
	}
	// Chance to add hazard
	if (Math.random() > 0.7) {
		var hazardType;
		var hazardRoll = Math.random();
		if (hazardRoll > 0.6) {
			hazardType = 'snowball';
		} else if (hazardRoll > 0.3) {
			hazardType = 'rock';
		} else {
			hazardType = 'gap';
		}
		if (hazardType === 'gap') {
			// Gaps are positioned on the path
			var gap = new Hazard(hazardType);
			gap.x = pathX;
			gap.y = yPosition - 25;
			hazards.push(gap);
			game.addChild(gap);
		} else {
			// Flying hazards are positioned above
			var hazard = new Hazard(hazardType);
			hazard.x = Math.random() * 2048;
			hazard.y = yPosition - 500 - Math.random() * 500;
			hazards.push(hazard);
			game.addChild(hazard);
		}
	}
	return path;
}
function updateGame() {
	if (!gameActive) {
		return;
	}
	// Update oxygen level
	updateOxygen();
	// Update climber and check collisions
	updateClimber();
	// Update paths and scroll
	updatePathsAndScroll();
	// Update hazards
	updateHazards();
	// Update collectables
	updateCollectables();
	// Update campsites
	updateCampsites();
	// Update UI
	updateUI();
	// Check for game over conditions
	checkGameOver();
	// Check for level complete
	checkLevelComplete();
}
function updateOxygen() {
	// Consume oxygen
	oxygen -= oxygenUseRate * (1 + weatherEffect);
	// Apply weather effects
	if (altitude > level * 1000) {
		weatherEffect = Math.min(1, (altitude - level * 1000) / 1000);
		// Reduce weather effect based on weather resistance upgrade
		weatherEffect *= 1 - weatherResistance * 0.1;
	}
	// Update oxygen bar
	oxygenBar.updateBar(oxygen);
}
function updateClimber() {
	// Update climber position
	climber.update();
	// Check if climber is on any path
	climber.onGround = false;
	for (var i = 0; i < paths.length; i++) {
		var path = paths[i];
		if (climber.intersects(path) && climber.lastY + climber.height / 2 <= path.y - path.height / 2 + 20 && climber.vy >= 0) {
			climber.y = path.y - path.height / 2 - climber.height / 2 + 5;
			climber.vy = 0;
			climber.onGround = true;
			climber.climbing = false;
			// If on slippery path, add slide effect
			if (path.pathType === 'slippery' && !climber.movingToTarget) {
				climber.vx = Math.random() > 0.5 ? 1 : -1;
			}
			break;
		}
	}
}
function updatePathsAndScroll() {
	// Scroll the screen when climber is higher
	if (climber.y < 2732 / 3) {
		var scrollAmount = 2732 / 3 - climber.y;
		camera.y += scrollAmount;
		climber.y += scrollAmount;
		// Move all game elements
		for (var i = 0; i < paths.length; i++) {
			paths[i].y += scrollAmount;
		}
		for (var i = 0; i < hazards.length; i++) {
			hazards[i].y += scrollAmount;
		}
		for (var i = 0; i < collectables.length; i++) {
			collectables[i].y += scrollAmount;
		}
		for (var i = 0; i < campsites.length; i++) {
			campsites[i].y += scrollAmount;
		}
		for (var i = 0; i < mountains.length; i++) {
			mountains[i].y += scrollAmount * 0.5; // Parallax effect
		}
		// Increase altitude based on current level
		altitude += scrollAmount + (level - 1) * levelHeight;
		// Create new paths as needed
		while (nextPathY > camera.y - 2732 / 2) {
			createPathAt(nextPathY);
			nextPathY -= pathGap + Math.random() * 50;
		}
	} else {
		// If the climber is not high enough, keep moving the game elements upwards
		var scrollAmount = scrollSpeed;
		camera.y += scrollAmount;
		climber.y += scrollAmount;
		for (var i = 0; i < paths.length; i++) {
			paths[i].y += scrollAmount;
		}
		for (var i = 0; i < hazards.length; i++) {
			hazards[i].y += scrollAmount;
		}
		for (var i = 0; i < collectables.length; i++) {
			collectables[i].y += scrollAmount;
		}
		for (var i = 0; i < campsites.length; i++) {
			campsites[i].y += scrollAmount;
		}
		for (var i = 0; i < mountains.length; i++) {
			mountains[i].y += scrollAmount * 0.5; // Parallax effect
		}
		altitude += scrollAmount;
		while (nextPathY > camera.y - 2732 / 2) {
			createPathAt(nextPathY);
			nextPathY -= pathGap + Math.random() * 50;
		}
	}
	// Remove paths that are off-screen
	for (var i = paths.length - 1; i >= 0; i--) {
		if (paths[i].y > camera.y + 2732 + 200) {
			paths[i].destroy();
			paths.splice(i, 1);
		}
	}
}
function updateHazards() {
	for (var i = hazards.length - 1; i >= 0; i--) {
		var hazard = hazards[i];
		hazard.update();
		// Check for collision with climber
		if (hazard.active && climber.intersects(hazard)) {
			handleHazardCollision(hazard);
		}
		// Remove inactive hazards
		if (!hazard.active || hazard.y > camera.y + 2732 + 200) {
			hazard.destroy();
			hazards.splice(i, 1);
		}
	}
}
function handleHazardCollision(hazard) {
	LK.getSound('danger').play();
	if (hazard.hazardType === 'rock' || hazard.hazardType === 'snowball') {
		// Falling rocks or snowballs damage oxygen
		oxygen -= 20;
		// Visual feedback
		LK.effects.flashObject(climber, 0xff0000, 500);
		// Knockback effect
		climber.vy = 5;
		climber.vx = climber.x < hazard.x ? -8 : 8;
		// Make hazard inactive
		hazard.active = false;
	} else if (hazard.hazardType === 'gap') {
		// Gaps are deadly if fallen into
		if (climber.vy > 0 && !climber.onGround) {
			gameActive = false;
		}
	}
}
function updateCollectables() {
	for (var i = collectables.length - 1; i >= 0; i--) {
		var collectable = collectables[i];
		collectable.update();
		// Check for collision with climber
		if (collectable.active && climber.intersects(collectable)) {
			handleCollectableCollision(collectable);
			// Remove collected item
			collectable.destroy();
			collectables.splice(i, 1);
		} else if (collectable.y > camera.y + 2732 + 200) {
			// Remove off-screen collectables
			collectable.destroy();
			collectables.splice(i, 1);
		}
	}
}
function handleCollectableCollision(collectable) {
	LK.getSound('collect').play();
	if (collectable.collectableType === 'oxygen') {
		// Refill oxygen
		oxygen = Math.min(maxOxygen, oxygen + collectable.value);
		// Visual feedback
		LK.effects.flashObject(collectable, 0x00BFFF, 300);
	} else if (collectable.collectableType === 'gear') {
		// Collect gear
		storage.gearCollected += collectable.value;
		// Add to score
		score += 10;
		// Visual feedback
		LK.effects.flashObject(collectable, 0xFFD700, 300);
	}
}
function updateCampsites() {
	for (var i = campsites.length - 1; i >= 0; i--) {
		var campsite = campsites[i];
		// Check for collision with climber
		if (campsite.active && climber.intersects(campsite)) {
			handleCampsiteCollision(campsite);
		}
		// Remove off-screen campsites
		if (campsite.y > camera.y + 2732 + 200) {
			campsite.destroy();
			campsites.splice(i, 1);
		}
	}
}
function handleCampsiteCollision(campsite) {
	// Rest at campsite to replenish oxygen
	if (climber.onGround && campsite.active) {
		LK.getSound('rest').play();
		// Replenish oxygen
		oxygen = Math.min(maxOxygen, oxygen + 0.5);
		// Visual feedback
		if (LK.ticks % 20 === 0) {
			LK.effects.flashObject(campsite, 0x4CBB17, 300);
		}
		// Increase score for time spent at campsite
		if (LK.ticks % 60 === 0) {
			score += 1;
		}
	}
}
function updateUI() {
	// Update score text
	scoreText.setText('SCORE: ' + Math.floor(score));
	// Update altitude text
	altitudeText.setText('ALTITUDE: ' + Math.floor(altitude) + ' M');
	// Update level text
	levelText.setText('LEVEL: ' + level);
}
function checkGameOver() {
	// Game over if oxygen depletes
	if (oxygen <= 0) {
		gameActive = false;
		oxygen = 0;
		LK.effects.flashScreen(0xff0000, 1000);
		LK.setTimeout(function () {
			LK.showGameOver();
		}, 1000);
	}
	// Game over if fallen off screen
	if (climber.y > camera.y + 2732 + climber.height) {
		gameActive = false;
		LK.effects.flashScreen(0xff0000, 1000);
		LK.setTimeout(function () {
			LK.showGameOver();
		}, 1000);
	}
}
function checkLevelComplete() {
	// Advance to next level when reaching required cumulative height
	if (altitude >= level * levelHeight) {
		level++;
		// Increase difficulty
		pathGap += 20;
		oxygenUseRate += 0.05;
		// Bonus score
		score += level * 100;
		// Flash screen for feedback
		LK.effects.flashScreen(0x00ff00, 500);
		// Maintain cumulative altitude for next level
		altitude = (level - 1) * levelHeight;
		// Reset oxygen to full for the next level
		oxygen = maxOxygen;
		// Reset paths, hazards, and collectables for new level
		paths = [];
		hazards = [];
		collectables = [];
		campsites = [];
		nextPathY = 2600 + (level - 1) * levelHeight; // Adjust start position for first path based on level
		// Create initial paths for new level
		for (var i = 0; i < 15; i++) {
			createPathAt(nextPathY);
			nextPathY -= pathGap;
		}
		// If reached final level (5), show win screen
		if (level > 5) {
			LK.setTimeout(function () {
				// Update high score
				if (score > storage.highScore) {
					storage.highScore = Math.floor(score);
				}
				LK.showYouWin();
			}, 1000);
		}
	}
}
// Interaction handlers
game.down = function (x, y, obj) {
	if (!gameActive) {
		return;
	}
	// Convert click to game coordinates
	var position = game.toLocal({
		x: x,
		y: y
	});
	// When clicking/tapping, move towards that point if within reasonable range
	var dx = position.x - climber.x;
	var dy = position.y - climber.y;
	var distance = Math.sqrt(dx * dx + dy * dy);
	// Move towards the target position
	climber.moveToPosition(position.x, position.y);
	climber.vy = -scrollSpeed; // Set vertical speed to move upwards
};
game.up = function (x, y, obj) {
	// Not needed for this game
};
game.move = function (x, y, obj) {
	// Not needed for this game
};
// Main game loop
game.update = function () {
	updateGame();
	// Update score based on altitude
	if (gameActive && LK.ticks % 30 === 0) {
		score += 0.1 * level;
	}
};
// Initialize the game
setupGame();
// Set game score
LK.setScore(Math.floor(score));

===================================================================
--- original.js
+++ change.js
@@ -640,9 +640,9 @@
 	}
 }
 function checkLevelComplete() {
 	// Advance to next level when reaching required cumulative height
-	if (altitude >= level * levelHeight + (level - 1) * levelHeight) {
+	if (altitude >= level * levelHeight) {
 		level++;
 		// Increase difficulty
 		pathGap += 20;
 		oxygenUseRate += 0.05;
@@ -650,17 +650,17 @@
 		score += level * 100;
 		// Flash screen for feedback
 		LK.effects.flashScreen(0x00ff00, 500);
 		// Maintain cumulative altitude for next level
-		altitude -= levelHeight;
+		altitude = (level - 1) * levelHeight;
 		// Reset oxygen to full for the next level
 		oxygen = maxOxygen;
 		// Reset paths, hazards, and collectables for new level
 		paths = [];
 		hazards = [];
 		collectables = [];
 		campsites = [];
-		nextPathY = 2600; // Reset start position for first path
+		nextPathY = 2600 + (level - 1) * levelHeight; // Adjust start position for first path based on level
 		// Create initial paths for new level
 		for (var i = 0; i < 15; i++) {
 			createPathAt(nextPathY);
 			nextPathY -= pathGap;