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

/**** 
* Classes
****/ 
var Orb = Container.expand(function () {
	var self = Container.call(this);
	var orbGraphics = self.attachAsset('orb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = (Math.random() - 0.5) * 16;
	self.velocityY = (Math.random() - 0.5) * 16;
	// Start random rotation animation
	self.startRotation = function () {
		var rotationDirection = Math.random() < 0.5 ? 1 : -1; // Random clockwise or counterclockwise
		var rotationSpeed = (Math.random() * 2 + 1) * rotationDirection; // Random speed between 1-3, with direction
		var currentRotation = orbGraphics.rotation;
		var targetRotation = currentRotation + Math.PI * 2 * rotationSpeed; // Full rotation in chosen direction
		tween(orbGraphics, {
			rotation: targetRotation
		}, {
			duration: 2000 + Math.random() * 3000,
			// Random duration between 2-5 seconds
			easing: tween.linear,
			onFinish: function onFinish() {
				self.startRotation(); // Continue rotating with new random parameters
			}
		});
	};
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Bounce off walls - only change direction 1 out of 10 times
		if (self.x <= 40 || self.x >= 2008) {
			if (Math.random() < 0.1) {
				// 10% chance to change direction
				self.velocityX *= -1;
			}
			self.x = Math.max(40, Math.min(2008, self.x));
		}
		if (self.y <= 40 || self.y >= 2692) {
			if (Math.random() < 0.1) {
				// 10% chance to change direction
				self.velocityY *= -1;
			}
			self.y = Math.max(40, Math.min(2692, self.y));
		}
	};
	// Start rotation animation when orb is created
	self.startRotation();
	return self;
});
var Stickman = Container.expand(function () {
	var self = Container.call(this);
	var stickmanGraphics = self.attachAsset('STICKMAN', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 12;
	self.wall = 'bottom'; // current wall: 'top', 'right', 'bottom', 'left'
	self.wallProgress = 0; // progress along current wall (0-1)
	self.isJumping = false;
	self.jumpStartWall = '';
	self.jumpStartProgress = 0;
	self.jumpProgress = 0;
	self.jumpTargetWall = null; // Target wall for redirected jumps
	self.update = function () {
		if (self.isJumping) {
			self.jumpProgress += 0.04;
			var startPos;
			if (self.jumpStartWall === 'current') {
				// Use current position as start for redirected jumps
				startPos = {
					x: self.x,
					y: self.y
				};
			} else {
				startPos = self.getWallPosition(self.jumpStartWall, self.jumpStartProgress);
			}
			// Use jumpTargetWall if set, otherwise use opposite wall
			var targetWall = self.jumpTargetWall || self.getOppositeWall(self.jumpStartWall);
			var endPos = self.getWallPosition(targetWall, 0.5);
			self.x = startPos.x + (endPos.x - startPos.x) * self.jumpProgress;
			self.y = startPos.y + (endPos.y - startPos.y) * self.jumpProgress;
			if (self.jumpProgress >= 1) {
				self.isJumping = false;
				self.wall = targetWall;
				self.wallProgress = 0.5;
				self.jumpProgress = 0;
				self.jumpTargetWall = null; // Reset target wall
				// Create impact effect
				createImpactEffect(self.x, self.y);
				damageTerrain(self.x, self.y);
				LK.getSound('impact').play();
			}
		} else {
			self.wallProgress += self.speed / 1000;
			if (self.wallProgress > 1) {
				self.wallProgress = 0;
				self.wall = self.getNextWall();
			}
			var pos = self.getWallPosition(self.wall, self.wallProgress);
			self.x = pos.x;
			self.y = pos.y;
			// Damage terrain as stickman runs
			if (LK.ticks % 15 === 0) {
				damageTerrain(self.x, self.y);
			}
		}
		// Rotate STICKMAN so top points toward center
		var centerX = 2048 / 2;
		var centerY = 2732 / 2;
		var angleToCenter = Math.atan2(centerY - self.y, centerX - self.x);
		// Add 90 degrees (Math.PI/2) so top of asset points toward center instead of side
		stickmanGraphics.rotation = angleToCenter + Math.PI / 2;
		// Randomly rotate sprite in any direction (but not in first third of wall and not while jumping)
		if (Math.random() < 0.005 && self.wallProgress > 0.33 && !self.isJumping) {
			// 0.5% chance per frame for less frequent but more varied rotations
			var currentRotation = stickmanGraphics.rotation;
			// Random rotation between -360 to 360 degrees (in radians)
			var randomRotation = (Math.random() - 0.5) * 4 * Math.PI;
			var targetRotation = currentRotation + randomRotation;
			tween(stickmanGraphics, {
				rotation: targetRotation
			}, {
				duration: 1000 + Math.random() * 1000,
				// Random duration between 1-2 seconds
				easing: tween.easeInOut
			});
		}
		// Randomly flip sprite horizontally
		if (Math.random() < 0.003) {
			// 0.3% chance per frame for horizontal flipping
			var currentScaleX = stickmanGraphics.scaleX;
			var targetScaleX = currentScaleX * -1; // Flip horizontally
			tween(stickmanGraphics, {
				scaleX: targetScaleX
			}, {
				duration: 800 + Math.random() * 400,
				// Random duration between 0.8-1.2 seconds
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					// After 2 seconds, return to normal horizontal orientation
					LK.setTimeout(function () {
						tween(stickmanGraphics, {
							scaleX: 1
						}, {
							duration: 800,
							easing: tween.easeInOut
						});
					}, 2000);
				}
			});
		}
	};
	self.getWallPosition = function (wall, progress) {
		switch (wall) {
			case 'top':
				return {
					x: progress * 2048,
					y: 20 + 70 // Match side wall contact distance
				};
			case 'right':
				return {
					x: 2028 - 70,
					// On top of terrain blocks (terrain x=2028, stickman width offset + 40px)
					y: 60 + progress * (2732 - 120)
				};
			case 'bottom':
				return {
					x: (1 - progress) * 2048,
					y: 2712 - 70 // Match side wall contact distance
				};
			case 'left':
				return {
					x: 20 + 70,
					// On top of terrain blocks (terrain x=20, stickman width offset + 40px)
					y: 2672 - progress * (2732 - 120)
				};
		}
	};
	self.getNextWall = function () {
		var walls = ['top', 'right', 'bottom', 'left'];
		var currentIndex = walls.indexOf(self.wall);
		return walls[(currentIndex - 1 + 4) % 4];
	};
	self.getOppositeWall = function (wall) {
		switch (wall) {
			case 'top':
				return 'bottom';
			case 'bottom':
				return 'top';
			case 'left':
				return 'right';
			case 'right':
				return 'left';
		}
	};
	self.jump = function () {
		if (!self.isJumping) {
			self.isJumping = true;
			self.jumpStartWall = self.wall;
			self.jumpStartProgress = self.wallProgress;
			self.jumpProgress = 0;
			self.jumpTargetWall = null; // Reset target wall for new jump
			LK.getSound('jump').play();
		}
	};
	return self;
});
var TerrainBlock = Container.expand(function () {
	var self = Container.call(this);
	var terrainGraphics = self.attachAsset('terrain', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 3;
	self.maxHealth = 3;
	self.damage = function () {
		self.health--;
		terrainGraphics.alpha = self.health / self.maxHealth;
		if (self.health <= 0) {
			self.destroy();
			return true; // Block destroyed
		}
		return false;
	};
	self.repair = function () {
		self.health = self.maxHealth;
		terrainGraphics.alpha = 1;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var stickman;
var orbs = [];
var terrainBlocks = [];
var orbsCollected = 0;
var gameTime = 0;
var destructionRate = 1;
// Create score display
var scoreTxt = new Text2('Score: 0', {
	size: 80,
	fill: 0x000000
});
scoreTxt.anchor.set(0.5, 0.5);
scoreTxt.alpha = 0.4; // Reduce opacity to make it less prominent
LK.gui.center.addChild(scoreTxt);
// Create orbs collected display
var orbTxt = new Text2('Orbs: 0', {
	size: 60,
	fill: 0xFFD700
});
orbTxt.anchor.set(0.5, 0.5);
orbTxt.y = 100; // Position below the score text
orbTxt.alpha = 0.4; // Reduce opacity to make it less prominent
LK.gui.center.addChild(orbTxt);
// Initialize stickman
stickman = game.addChild(new Stickman());
var pos = stickman.getWallPosition('bottom', 0);
stickman.x = pos.x;
stickman.y = pos.y;
// Initialize orb
var firstOrb = game.addChild(new Orb());
firstOrb.x = 1024;
firstOrb.y = 1366;
orbs.push(firstOrb);
// Create initial terrain blocks around perimeter
function createInitialTerrain() {
	// Top wall
	for (var i = 0; i < 17; i++) {
		var block = new TerrainBlock();
		block.x = i * 120 + 60;
		block.y = 20;
		terrainBlocks.push(block);
		game.addChild(block);
	}
	// Bottom wall
	for (var i = 0; i < 17; i++) {
		var block = new TerrainBlock();
		block.x = i * 120 + 60;
		block.y = 2712;
		terrainBlocks.push(block);
		game.addChild(block);
	}
	// Left wall
	for (var i = 1; i < 22; i++) {
		var block = new TerrainBlock();
		block.x = 20;
		block.y = i * 120 + 60;
		block.rotation = Math.PI / 2; // Rotate 90 degrees toward center
		terrainBlocks.push(block);
		game.addChild(block);
	}
	// Right wall
	for (var i = 1; i < 22; i++) {
		var block = new TerrainBlock();
		block.x = 2028;
		block.y = i * 120 + 60;
		block.rotation = -Math.PI / 2; // Rotate 90 degrees toward center
		terrainBlocks.push(block);
		game.addChild(block);
	}
}
function createImpactEffect(x, y) {
	var effect = LK.getAsset('impactEffect', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: x,
		y: y,
		alpha: 0.8
	});
	game.addChild(effect);
	tween(effect, {
		scaleX: 2,
		scaleY: 2,
		alpha: 0
	}, {
		duration: 500,
		onFinish: function onFinish() {
			effect.destroy();
		}
	});
}
function damageTerrain(x, y) {
	var damageRadius = 150;
	for (var i = terrainBlocks.length - 1; i >= 0; i--) {
		var block = terrainBlocks[i];
		var distance = Math.sqrt((block.x - x) * (block.x - x) + (block.y - y) * (block.y - y));
		if (distance < damageRadius) {
			if (block.damage()) {
				terrainBlocks.splice(i, 1);
			}
		}
	}
}
function repairTerrain() {
	for (var i = 0; i < terrainBlocks.length; i++) {
		terrainBlocks[i].repair();
	}
}
function createNewOrb() {
	if (orbs.length >= 10) return null; // Limit maximum orbs
	var newOrb = game.addChild(new Orb());
	newOrb.x = 200 + Math.random() * 1648;
	newOrb.y = 200 + Math.random() * 2332;
	newOrb.velocityX = (Math.random() - 0.5) * 16;
	newOrb.velocityY = (Math.random() - 0.5) * 16;
	orbs.push(newOrb);
	return newOrb;
}
function checkCollisions() {
	// Check orb collisions
	for (var i = orbs.length - 1; i >= 0; i--) {
		var currentOrb = orbs[i];
		var distance = Math.sqrt((stickman.x - currentOrb.x) * (stickman.x - currentOrb.x) + (stickman.y - currentOrb.y) * (stickman.y - currentOrb.y));
		if (distance < 70) {
			// Only allow collection and rewards if we haven't reached maximum collected orbs
			if (orbsCollected < 10) {
				orbsCollected++;
				LK.setScore(LK.getScore() + 100);
				scoreTxt.setText('Score: ' + LK.getScore());
				orbTxt.setText('Orbs: ' + orbsCollected);
				// Repair terrain
				repairTerrain();
				// Remove collected orb
				currentOrb.destroy();
				orbs.splice(i, 1);
				// Split into 2 new orbs (if under limit)
				createNewOrb();
				createNewOrb();
				LK.getSound('collect').play();
				// Flash effect
				LK.effects.flashScreen(0xFFD700, 300);
				break; // Only collect one orb per frame
			} else {
				// At maximum orbs - make orb disappear without rewards
				currentOrb.destroy();
				orbs.splice(i, 1);
				break; // Only process one orb per frame
			}
		}
	}
}
function checkGameOver() {
	if (terrainBlocks.length < 10) {
		LK.showGameOver();
	}
}
// Initialize terrain
createInitialTerrain();
// Game controls
game.down = function (x, y, obj) {
	if (obj.event && obj.event.button !== undefined) {
		// Handle mouse button clicks during jumping
		if (stickman.isJumping) {
			if (obj.event.button === 0) {
				// Left click - redirect to bottom wall
				stickman.jumpTargetWall = 'bottom';
				// Update jump start position to current position for smooth redirection
				stickman.jumpStartWall = 'current';
				stickman.jumpStartProgress = 0;
				stickman.jumpProgress = 0;
			} else if (obj.event.button === 2) {
				// Right click - redirect to top wall  
				stickman.jumpTargetWall = 'top';
				// Update jump start position to current position for smooth redirection
				stickman.jumpStartWall = 'current';
				stickman.jumpStartProgress = 0;
				stickman.jumpProgress = 0;
			}
		} else {
			// Regular jump when not already jumping
			stickman.jump();
		}
	} else {
		// Fallback for touch devices - regular jump
		stickman.jump();
	}
};
// Main game loop
game.update = function () {
	gameTime++;
	// Increase destruction rate over time
	if (gameTime % 1800 === 0) {
		// Every 30 seconds
		destructionRate += 0.5;
	}
	// Random terrain destruction
	if (Math.random() < 0.001 * destructionRate && terrainBlocks.length > 0) {
		var randomIndex = Math.floor(Math.random() * terrainBlocks.length);
		var block = terrainBlocks[randomIndex];
		if (block.damage()) {
			terrainBlocks.splice(randomIndex, 1);
		}
	}
	// Update score based on survival time
	if (gameTime % 60 === 0) {
		// Every second
		LK.setScore(LK.getScore() + 10);
		scoreTxt.setText('Score: ' + LK.getScore());
	}
	checkCollisions();
	checkGameOver();
};

===================================================================
--- original.js
+++ change.js
@@ -33,15 +33,21 @@
 	};
 	self.update = function () {
 		self.x += self.velocityX;
 		self.y += self.velocityY;
-		// Bounce off walls
+		// Bounce off walls - only change direction 1 out of 10 times
 		if (self.x <= 40 || self.x >= 2008) {
-			self.velocityX *= -1;
+			if (Math.random() < 0.1) {
+				// 10% chance to change direction
+				self.velocityX *= -1;
+			}
 			self.x = Math.max(40, Math.min(2008, self.x));
 		}
 		if (self.y <= 40 || self.y >= 2692) {
-			self.velocityY *= -1;
+			if (Math.random() < 0.1) {
+				// 10% chance to change direction
+				self.velocityY *= -1;
+			}
 			self.y = Math.max(40, Math.min(2692, self.y));
 		}
 	};
 	// Start rotation animation when orb is created