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

/**** 
* Classes
****/ 
var Claw = Container.expand(function () {
	var self = Container.call(this);
	var clawGraphics = self.attachAsset('claw', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Cable removed - no longer visible
	self.swingAngle = 0;
	self.swingSpeed = 0.02;
	self.swingRadius = 300;
	self.centerX = 1024; // Center position
	self.startX = 1024; // Starting X position - same as center
	self.isDropping = false;
	self.isRetracting = false;
	self.dropSpeed = 8;
	self.retractSpeed = 6;
	self.startY = 350;
	self.grabbedItem = null;
	self.weight = 1;
	self.isRetractingStarted = false;
	self.update = function () {
		if (!self.isDropping && !self.isRetracting) {
			// Swing back and forth by rotating the claw
			self.swingAngle += self.swingSpeed;
			self.rotation = Math.sin(self.swingAngle) * 2.0; // Rotate between -2.0 and 2.0 radians for much wider swing, better matching visual angle
		}
		// Dropping is now handled by tween animation in drop() method
		if (self.isRetracting && !self.isRetractingStarted) {
			self.isRetractingStarted = true;
			// Calculate distance back to start position
			var distanceBack = Math.sqrt(Math.pow(self.startX - self.x, 2) + Math.pow(self.startY - self.y, 2));
			// Base retraction speed (pixels per second) - slower when carrying items
			var baseRetractSpeed = 600; // pixels per second when empty
			var weightedRetractSpeed = baseRetractSpeed / self.weight; // Slower for heavier items
			var retractDuration = distanceBack / weightedRetractSpeed * 1000; // Convert to milliseconds
			// Use tween to move claw back to start position
			tween(self, {
				x: self.startX,
				y: self.startY
			}, {
				duration: retractDuration,
				easing: tween.linear,
				onFinish: function onFinish() {
					self.isRetracting = false;
					self.isRetractingStarted = false;
					// Use a small delay to ensure item collection happens cleanly
					if (self.grabbedItem) {
						LK.setTimeout(function () {
							if (self.grabbedItem) {
								// Double check item still exists
								self.collectItem();
							}
						}, 50);
					}
				}
			});
		}
		// Move grabbed item with claw
		if (self.grabbedItem) {
			self.grabbedItem.x = self.x;
			self.grabbedItem.y = self.y + 40;
		}
		// Cable positioning removed - cable is now invisible
	};
	self.drop = function () {
		if (!self.isDropping && !self.isRetracting) {
			self.isDropping = true;
			// Calculate target position based on current rotation
			var targetDistance = 1800; // How far the claw should extend - increased to reach bottom of screen
			// Use the actual rotation of the claw to determine direction
			var angle = self.rotation; // self.rotation is in radians, 0 is downward
			var targetX = self.centerX + Math.sin(angle) * targetDistance;
			var targetY = self.startY + Math.cos(angle) * targetDistance;
			// Ensure claw stays within screen bounds
			if (targetX < 50) targetX = 50;
			if (targetX > 1998) targetX = 1998;
			// Calculate distance to target
			var distance = Math.sqrt(Math.pow(targetX - self.x, 2) + Math.pow(targetY - self.y, 2));
			// Use constant speed for dropping (pixels per second)
			var dropSpeed = 800; // pixels per second
			var dropDuration = distance / dropSpeed * 1000; // Convert to milliseconds
			// Use tween to move claw directly to target position
			tween(self, {
				x: targetX,
				y: targetY
			}, {
				duration: dropDuration,
				easing: tween.linear,
				onFinish: function onFinish() {
					self.isDropping = false;
					self.isRetracting = true;
				}
			});
			LK.getSound('clawMove').play();
		}
	};
	self.collectItem = function () {
		if (self.grabbedItem) {
			var itemToCollect = self.grabbedItem; // Store reference before clearing
			self.grabbedItem = null; // Clear reference immediately to prevent double collection
			self.weight = 1; // Reset weight immediately
			// Add to score based on item type
			var points = 0;
			if (itemToCollect.itemType === 'gold') {
				points = 50;
			} else if (itemToCollect.itemType === 'diamond') {
				points = 100;
			} else if (itemToCollect.itemType === 'rock') {
				points = 10;
			} else if (itemToCollect.itemType === 'pig') {
				points = 150; // Higher value for pig with diamond
			} else if (itemToCollect.itemType === 'tnt') {
				// TNT explodes and resets score to 0
				LK.setScore(0);
				scoreText.setText('Score: 0');
				// Flash screen red for explosion effect
				LK.effects.flashScreen(0xFF0000, 1000);
				points = 0;
			}
			if (itemToCollect.itemType !== 'tnt') {
				LK.setScore(LK.getScore() + points);
				scoreText.setText('Score: ' + LK.getScore());
			}
			// Remove item from items array
			for (var i = items.length - 1; i >= 0; i--) {
				if (items[i] === itemToCollect) {
					items[i].destroy();
					items.splice(i, 1);
					break;
				}
			}
			LK.getSound('collect').play();
		}
	};
	return self;
});
var Miner = Container.expand(function () {
	var self = Container.call(this);
	// Create miner character using a shape asset
	var minerGraphics = self.attachAsset('miner', {
		anchorX: 0.5,
		anchorY: 1
	});
	return self;
});
var MiningItem = Container.expand(function (itemType) {
	var self = Container.call(this);
	self.itemType = itemType;
	var assetName = '';
	var scale = 1;
	if (itemType === 'gold') {
		assetName = 'goldNugget';
		self.weight = 1.5;
		// Random scale between 0.7 and 1.3
		scale = 0.7 + Math.random() * 0.6;
		self.weight *= scale; // Adjust weight based on size
	} else if (itemType === 'diamond') {
		assetName = 'diamond';
		self.weight = 1;
	} else if (itemType === 'rock') {
		assetName = 'rock';
		self.weight = 3;
		// Random scale between 0.6 and 1.4
		scale = 0.6 + Math.random() * 0.8;
		self.weight *= scale; // Adjust weight based on size
	} else if (itemType === 'tnt') {
		assetName = 'tnt';
		self.weight = 2;
	}
	var itemGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Apply random scale
	itemGraphics.scaleX = scale;
	itemGraphics.scaleY = scale;
	return self;
});
var Pig = Container.expand(function () {
	var self = Container.call(this);
	var pigGraphics = self.attachAsset('pig', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var diamond = self.attachAsset('diamond', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	diamond.x = 0;
	diamond.y = -10; // Position diamond in pig's "mouth"
	diamond.scaleX = 0.6;
	diamond.scaleY = 0.6;
	// Random movement speed between 0.5 and 2.5
	self.moveSpeed = 0.5 + Math.random() * 2;
	// Random initial direction
	self.direction = Math.random() < 0.5 ? -1 : 1;
	// Random movement range between 150 and 350
	self.moveRange = 150 + Math.random() * 200;
	self.startX = 0;
	self.itemType = 'pig';
	self.weight = 2;
	self.update = function () {
		// Move pig back and forth
		self.x += self.moveSpeed * self.direction;
		if (self.x > self.startX + self.moveRange || self.x < self.startX - self.moveRange) {
			self.direction *= -1;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game assets will be created dynamically
// Game variables
var claw;
var items = [];
var gameTime = 60; // 60 seconds per level
var timeLeft = gameTime;
var gameActive = true;
var scoreText;
var timeText;
var gameTimer;
// Create sky background
var sky = game.attachAsset('sky', {
	x: 0,
	y: 0
});
// Create ground
var ground = game.attachAsset('ground', {
	x: 0,
	y: 300
});
// Create miner character
var miner = game.addChild(new Miner());
miner.x = 1024;
miner.y = 300;
// Create claw
claw = game.addChild(new Claw());
claw.x = 1024;
claw.y = 350;
// Create UI elements
scoreText = new Text2('Score: 0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0, 0);
LK.gui.topLeft.addChild(scoreText);
scoreText.x = 120; // Avoid top-left menu area
timeText = new Text2('Time: 60', {
	size: 80,
	fill: 0xFFFFFF
});
timeText.anchor.set(1, 0);
LK.gui.topRight.addChild(timeText);
// Generate random items underground
function generateItems() {
	var itemTypes = ['gold', 'diamond', 'rock', 'tnt'];
	var itemCount = 25;
	var tntCount = 0;
	var maxTnt = 3;
	var occupiedPositions = []; // Track positions to prevent overlap
	var minDistance = 120; // Minimum distance between items
	for (var i = 0; i < itemCount; i++) {
		var itemType = itemTypes[Math.floor(Math.random() * itemTypes.length)];
		// Limit TNT to 3 pieces maximum
		if (itemType === 'tnt') {
			if (tntCount >= maxTnt) {
				// Replace with another item type
				itemType = itemTypes[Math.floor(Math.random() * (itemTypes.length - 1))]; // Exclude TNT
			} else {
				tntCount++;
			}
		}
		var item = new MiningItem(itemType);
		// Find a position that doesn't overlap with existing items
		var validPosition = false;
		var attempts = 0;
		var maxAttempts = 50;
		while (!validPosition && attempts < maxAttempts) {
			// Random position underground - moved much further down
			item.x = Math.random() * 1800 + 124; // Keep within bounds
			item.y = Math.random() * 1200 + 800; // Much deeper underground area
			// Check if position is far enough from other items
			validPosition = true;
			for (var j = 0; j < occupiedPositions.length; j++) {
				var distance = Math.sqrt(Math.pow(item.x - occupiedPositions[j].x, 2) + Math.pow(item.y - occupiedPositions[j].y, 2));
				if (distance < minDistance) {
					validPosition = false;
					break;
				}
			}
			attempts++;
		}
		// Store position for overlap checking
		occupiedPositions.push({
			x: item.x,
			y: item.y
		});
		items.push(item);
		game.addChild(item);
	}
	// Add moving pigs with diamonds - also moved further down
	var pigCount = 3;
	for (var i = 0; i < pigCount; i++) {
		var pig = new Pig();
		// Find position that doesn't overlap with items
		var validPosition = false;
		var attempts = 0;
		var maxAttempts = 50;
		while (!validPosition && attempts < maxAttempts) {
			pig.x = Math.random() * 1600 + 200;
			pig.y = Math.random() * 600 + 1000; // Much deeper underground
			// Check if position is far enough from other items
			validPosition = true;
			for (var j = 0; j < occupiedPositions.length; j++) {
				var distance = Math.sqrt(Math.pow(pig.x - occupiedPositions[j].x, 2) + Math.pow(pig.y - occupiedPositions[j].y, 2));
				if (distance < minDistance) {
					validPosition = false;
					break;
				}
			}
			attempts++;
		}
		pig.startX = pig.x;
		occupiedPositions.push({
			x: pig.x,
			y: pig.y
		});
		items.push(pig);
		game.addChild(pig);
	}
}
// Initialize items
generateItems();
// Game timer
gameTimer = LK.setInterval(function () {
	if (gameActive) {
		timeLeft--;
		timeText.setText('Time: ' + timeLeft);
		if (timeLeft <= 0) {
			gameActive = false;
			LK.clearInterval(gameTimer);
			// Small delay before showing game over
			LK.setTimeout(function () {
				LK.showGameOver();
			}, 500);
		}
	}
}, 1000);
// Touch/click handler for dropping claw
game.down = function (x, y, obj) {
	if (gameActive) {
		claw.drop();
	}
};
// Main game update loop
game.update = function () {
	if (!gameActive) return;
	// Check for item collection - only when claw (not cable) touches items
	if (claw.isDropping && !claw.grabbedItem) {
		for (var i = 0; i < items.length; i++) {
			var item = items[i];
			// Check collision using distance-based detection focused on claw position
			// This ensures only the claw itself (not the cable) triggers collection
			var clawCenterX = claw.x;
			var clawCenterY = claw.y;
			var itemCenterX = item.x;
			var itemCenterY = item.y;
			var distance = Math.sqrt(Math.pow(clawCenterX - itemCenterX, 2) + Math.pow(clawCenterY - itemCenterY, 2));
			var clawRadius = 40; // Approximate claw size
			var itemRadius = 50; // Approximate item size
			var clawTouchesItem = distance < clawRadius + itemRadius;
			if (clawTouchesItem) {
				claw.grabbedItem = item;
				claw.weight = item.weight;
				claw.isDropping = false;
				claw.isRetracting = true;
				break;
			}
		}
	}
	// Update score display
	scoreText.setText('Score: ' + LK.getScore());
};
// Play background music
LK.playMusic('bgmusic');

===================================================================
--- original.js
+++ change.js
@@ -75,11 +75,12 @@
 		if (!self.isDropping && !self.isRetracting) {
 			self.isDropping = true;
 			// Calculate target position based on current rotation
 			var targetDistance = 1800; // How far the claw should extend - increased to reach bottom of screen
-			// Fix the rotation calculation - use negative sin to match visual rotation direction
-			var targetX = self.centerX + Math.sin(-self.rotation) * targetDistance;
-			var targetY = self.startY + targetDistance;
+			// Use the actual rotation of the claw to determine direction
+			var angle = self.rotation; // self.rotation is in radians, 0 is downward
+			var targetX = self.centerX + Math.sin(angle) * targetDistance;
+			var targetY = self.startY + Math.cos(angle) * targetDistance;
 			// Ensure claw stays within screen bounds
 			if (targetX < 50) targetX = 50;
 			if (targetX > 1998) targetX = 1998;
 			// Calculate distance to target