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

/**** 
* Classes
****/ 
var Anchor = Container.expand(function (size) {
	var self = Container.call(this);
	// Determine anchor asset and properties based on size
	self.size = size || 'medium';
	var assetName = 'anchor_' + self.size;
	var anchorGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add range indicator graphics
	var rangeAssetName = 'range_' + self.size;
	var rangeGraphics = self.attachAsset(rangeAssetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	rangeGraphics.alpha = 0.1; // Make it semi-transparent
	rangeGraphics.tint = 0x44aa44; // Green tint
	// Range and score vary by size - increased ranges for better grappling
	if (self.size === 'small') {
		self.range = 250;
		self.scoreValue = 15;
	} else if (self.size === 'large') {
		self.range = 350;
		self.scoreValue = 5;
	} else {
		self.range = 300;
		self.scoreValue = 10;
	}
	self.used = false;
	self.update = function () {
		// Pulse animation
		var scale = 1 + Math.sin(LK.ticks * 0.1) * 0.1;
		anchorGraphics.scaleX = scale;
		anchorGraphics.scaleY = scale;
		// Scale range indicator proportionally to anchor size
		var rangeScale = scale;
		if (self.size === 'small') {
			rangeScale *= 0.8; // Smaller range visual for small anchors
		} else if (self.size === 'large') {
			rangeScale *= 1.2; // Larger range visual for large anchors
		}
		rangeGraphics.scaleX = rangeScale;
		rangeGraphics.scaleY = rangeScale;
	};
	self.isInRange = function (playerX, playerY) {
		var distance = Math.sqrt(Math.pow(self.x - playerX, 2) + Math.pow(self.y - playerY, 2));
		return distance <= self.range;
	};
	return self;
});
var GrappleLine = Container.expand(function () {
	var self = Container.call(this);
	self.segments = [];
	self.createLine = function (startX, startY, endX, endY) {
		// Clear existing segments
		for (var i = 0; i < self.segments.length; i++) {
			self.segments[i].destroy();
		}
		self.segments = [];
		// Calculate line segments
		var distance = Math.sqrt(Math.pow(endX - startX, 2) + Math.pow(endY - startY, 2));
		var segmentCount = Math.floor(distance / 20); // One segment every 20 pixels
		for (var i = 0; i < segmentCount; i++) {
			var t = i / segmentCount;
			var segmentX = startX + (endX - startX) * t;
			var segmentY = startY + (endY - startY) * t;
			var segment = self.attachAsset('grapple_line', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			segment.x = segmentX;
			segment.y = segmentY;
			self.segments.push(segment);
		}
	};
	self.clear = function () {
		for (var i = 0; i < self.segments.length; i++) {
			self.segments[i].destroy();
		}
		self.segments = [];
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.speed = 12;
	self.isGrappling = false;
	self.grappleAnchor = null;
	self.grappleDistance = 0;
	self.grappleAngle = 0;
	self.swingDirection = 1;
	self.trail = [];
	self.grappleLine = null;
	self.update = function () {
		if (self.isGrappling && self.grappleAnchor) {
			// Swing around anchor point using calculated swing direction
			self.grappleAngle += 0.08 * self.swingDirection;
			self.x = self.grappleAnchor.x + Math.cos(self.grappleAngle) * self.grappleDistance;
			self.y = self.grappleAnchor.y + Math.sin(self.grappleAngle) * self.grappleDistance;
			// Update velocity based on swing direction
			var nextAngle = self.grappleAngle + 0.08 * self.swingDirection;
			var nextX = self.grappleAnchor.x + Math.cos(nextAngle) * self.grappleDistance;
			var nextY = self.grappleAnchor.y + Math.sin(nextAngle) * self.grappleDistance;
			self.velocityX = (nextX - self.x) * 1.5;
			self.velocityY = (nextY - self.y) * 1.5;
			// Update grapple line
			if (self.grappleLine) {
				self.grappleLine.createLine(self.x, self.y, self.grappleAnchor.x, self.grappleAnchor.y);
			}
		} else {
			// Move in straight line
			self.x += self.velocityX;
			self.y += self.velocityY;
		}
		// Add trail effect
		self.trail.push({
			x: self.x,
			y: self.y
		});
		if (self.trail.length > 10) {
			self.trail.shift();
		}
	};
	self.startGrapple = function (anchor) {
		if (!self.isGrappling) {
			self.isGrappling = true;
			self.grappleAnchor = anchor;
			self.grappleDistance = Math.sqrt(Math.pow(self.x - anchor.x, 2) + Math.pow(self.y - anchor.y, 2));
			self.grappleAngle = Math.atan2(self.y - anchor.y, self.x - anchor.x);
			// Calculate swing direction based on player's velocity and position relative to anchor
			var velocityAngle = Math.atan2(self.velocityY, self.velocityX);
			var toAnchorAngle = Math.atan2(anchor.y - self.y, anchor.x - self.x);
			var angleDiff = velocityAngle - toAnchorAngle;
			// Normalize angle difference to [-π, π]
			while (angleDiff > Math.PI) angleDiff -= 2 * Math.PI;
			while (angleDiff < -Math.PI) angleDiff += 2 * Math.PI;
			// Determine swing direction: positive for clockwise, negative for counter-clockwise
			self.swingDirection = angleDiff > 0 ? 1 : -1;
			// Create grapple line
			if (!self.grappleLine) {
				self.grappleLine = game.addChild(new GrappleLine());
			}
			self.grappleLine.createLine(self.x, self.y, anchor.x, anchor.y);
			LK.getSound('grapple').play();
			// Visual feedback
			tween(anchor, {
				scaleX: 1.3,
				scaleY: 1.3
			}, {
				duration: 200,
				easing: tween.easeOut
			});
			tween(anchor, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 300,
				easing: tween.easeIn
			});
		}
	};
	self.releaseGrapple = function () {
		if (self.isGrappling) {
			self.isGrappling = false;
			self.grappleAnchor = null;
			// Clear grapple line
			if (self.grappleLine) {
				self.grappleLine.clear();
			}
			LK.getSound('release').play();
			// Normalize velocity
			var speed = Math.sqrt(self.velocityX * self.velocityX + self.velocityY * self.velocityY);
			if (speed > 0) {
				self.velocityX = self.velocityX / speed * self.speed;
				self.velocityY = self.velocityY / speed * self.speed;
			}
		}
	};
	return self;
});
var Wall = Container.expand(function () {
	var self = Container.call(this);
	var wallGraphics = self.attachAsset('wall', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var player;
var anchors = [];
var walls = [];
var gameSpeed = 1;
var distanceTraveled = 0;
var lastAnchorY = 0;
var lastWallY = 0;
// UI elements
var scoreTxt = new Text2('0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
var distanceTxt = new Text2('0m', {
	size: 60,
	fill: 0x888888
});
distanceTxt.anchor.set(0.5, 0);
distanceTxt.y = 100;
LK.gui.top.addChild(distanceTxt);
// Add background
var skyBackground = game.attachAsset('sky_background', {
	anchorX: 0,
	anchorY: 0
});
skyBackground.x = 0;
skyBackground.y = 0;
// Initialize player
player = game.addChild(new Player());
player.x = 1024;
player.y = 2200;
player.velocityX = 0;
player.velocityY = -player.speed;
// Generate initial anchors
function generateAnchor(x, y) {
	var sizes = ['small', 'medium', 'large'];
	var randomSize = sizes[Math.floor(Math.random() * sizes.length)];
	var anchor = new Anchor(randomSize);
	anchor.x = x;
	anchor.y = y;
	anchors.push(anchor);
	game.addChild(anchor);
	return anchor;
}
function generateWall(x, y, width, height) {
	var wall = new Wall();
	wall.x = x;
	wall.y = y;
	if (width) wall.width = width;
	if (height) wall.height = height;
	walls.push(wall);
	game.addChild(wall);
	return wall;
}
// Generate initial level - reduced anchor count for increased difficulty
for (var i = 0; i < 5; i++) {
	var anchorX = 400 + Math.random() * 1248;
	var anchorY = 2000 - i * 500; // Increased spacing between initial anchors
	generateAnchor(anchorX, anchorY);
	lastAnchorY = anchorY;
}
// Walls removed - no obstacles to crash into
// Mouse hold grappling mechanism
game.down = function (x, y, obj) {
	// Start grappling when mouse is pressed down
	if (!player.isGrappling) {
		// Find nearest anchor in range
		var nearestAnchor = null;
		var nearestDistance = Infinity;
		for (var i = 0; i < anchors.length; i++) {
			var anchor = anchors[i];
			if (anchor.isInRange(player.x, player.y)) {
				var distance = Math.sqrt(Math.pow(player.x - anchor.x, 2) + Math.pow(player.y - anchor.y, 2));
				if (distance < nearestDistance) {
					nearestDistance = distance;
					nearestAnchor = anchor;
				}
			}
		}
		if (nearestAnchor) {
			player.startGrapple(nearestAnchor);
			if (!nearestAnchor.used) {
				nearestAnchor.used = true;
				LK.setScore(LK.getScore() + nearestAnchor.scoreValue);
				scoreTxt.setText(LK.getScore());
			}
		}
	}
};
// Mouse release handler - release grapple when mouse is released
game.up = function (x, y, obj) {
	// Release grappling when mouse is released
	if (player.isGrappling) {
		player.releaseGrapple();
	}
};
// Game update loop
game.update = function () {
	// Update distance
	distanceTraveled += Math.abs(player.velocityY) * 0.1;
	distanceTxt.setText(Math.floor(distanceTraveled) + 'm');
	// Increase game speed gradually
	gameSpeed = 1 + distanceTraveled * 0.001;
	// Generate new anchors as player moves up - reduced frequency for increased difficulty
	if (player.y < lastAnchorY + 500) {
		// Generate only 1 anchor instead of 3 to increase spacing
		var anchorX = 200 + Math.random() * 1648;
		var anchorY = lastAnchorY - 400 - Math.random() * 200; // Increased spacing
		generateAnchor(anchorX, anchorY);
		lastAnchorY -= 500; // Increased distance between anchor generations
	}
	// Generate strategic obstacles occasionally for difficulty
	if (player.y < lastWallY + 800 && Math.random() < 0.3) {
		// Create narrow passages or single walls at strategic positions
		if (Math.random() < 0.5) {
			// Single wall obstacle
			var wallX = 300 + Math.random() * 1448;
			var wallY = lastWallY - 600 - Math.random() * 200;
			generateWall(wallX, wallY, 150, 30);
		} else {
			// Narrow passage between two walls
			var gapCenter = 400 + Math.random() * 1248;
			var gapSize = 300 + Math.random() * 200;
			var wallY = lastWallY - 600 - Math.random() * 200;
			// Left wall
			generateWall(gapCenter - gapSize / 2 - 100, wallY, 200, 30);
			// Right wall
			generateWall(gapCenter + gapSize / 2 + 100, wallY, 200, 30);
		}
		lastWallY -= 800;
	}
	for (var i = anchors.length - 1; i >= 0; i--) {
		var anchor = anchors[i];
		if (anchor.y > player.y + 1000) {
			anchor.destroy();
			anchors.splice(i, 1);
		}
	}
	// Clean up old walls
	for (var i = walls.length - 1; i >= 0; i--) {
		var wall = walls[i];
		if (wall.y > player.y + 1000) {
			wall.destroy();
			walls.splice(i, 1);
		}
	}
	// Wall collision detection
	for (var i = 0; i < walls.length; i++) {
		var wall = walls[i];
		if (player.intersects(wall)) {
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
			return;
		}
	}
	if (player.x < 0 || player.x > 2048 || player.y > 2732 + 200) {
		LK.effects.flashScreen(0xff0000, 1000);
		LK.showGameOver();
		return;
	}
	// Camera follow (move everything down as player moves up)
	if (player.y < 1366) {
		var offset = 1366 - player.y;
		player.y = 1366;
		// Move all anchors down
		for (var i = 0; i < anchors.length; i++) {
			anchors[i].y += offset;
		}
		// Move all walls down
		for (var i = 0; i < walls.length; i++) {
			walls[i].y += offset;
		}
		lastAnchorY += offset;
		lastWallY += offset;
	}
};

===================================================================
--- original.js
+++ change.js
@@ -232,8 +232,15 @@
 });
 distanceTxt.anchor.set(0.5, 0);
 distanceTxt.y = 100;
 LK.gui.top.addChild(distanceTxt);
+// Add background
+var skyBackground = game.attachAsset('sky_background', {
+	anchorX: 0,
+	anchorY: 0
+});
+skyBackground.x = 0;
+skyBackground.y = 0;
 // Initialize player
 player = game.addChild(new Player());
 player.x = 1024;
 player.y = 2200;
@@ -351,17 +358,8 @@
 			wall.destroy();
 			walls.splice(i, 1);
 		}
 	}
-	// Anchor collision detection - collide with anchor itself, not range area
-	for (var i = 0; i < anchors.length; i++) {
-		var anchor = anchors[i];
-		if (player.intersects(anchor)) {
-			LK.effects.flashScreen(0xff0000, 1000);
-			LK.showGameOver();
-			return;
-		}
-	}
 	// Wall collision detection
 	for (var i = 0; i < walls.length; i++) {
 		var wall = walls[i];
 		if (player.intersects(wall)) {