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

/**** 
* Classes
****/ 
var Blueberry = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('blueberry', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.baseSize = 80;
	self.growthFactor = 1.0;
	self.velocityX = 0;
	self.velocityY = 0;
	self.friction = 0.95;
	self.bounceForce = 0.7;
	self.grow = function () {
		self.growthFactor += 0.03;
		graphics.scaleX = self.growthFactor;
		graphics.scaleY = self.growthFactor;
	};
	self.getBounds = function () {
		var radius = self.baseSize * self.growthFactor / 2;
		return {
			left: self.x - radius,
			right: self.x + radius,
			top: self.y - radius,
			bottom: self.y + radius,
			radius: radius
		};
	};
	self.update = function () {
		// Apply gravity only when not being dragged
		if (dragNode !== self) {
			self.velocityY += gravity;
		}
		self.x += self.velocityX;
		self.y += self.velocityY;
		self.velocityX *= self.friction;
		self.velocityY *= self.friction;
		// Continuous rolling based on horizontal movement
		if (Math.abs(self.velocityX) > 0.05) {
			var rollDirection = self.velocityX > 0 ? 1 : -1;
			graphics.rotation += rollDirection * Math.abs(self.velocityX) * 0.02;
		}
		var bounds = self.getBounds();
		var bounced = false;
		if (bounds.left <= 0) {
			self.x = bounds.radius;
			self.velocityX = Math.abs(self.velocityX) * self.bounceForce;
			bounced = true;
			// Add rolling animation when bouncing off left wall
			if (Math.abs(self.velocityX) > 0.1) {
				var rollSpeed = Math.abs(self.velocityX) * 0.1;
				tween(graphics, {
					rotation: graphics.rotation + Math.PI * 2
				}, {
					duration: 1000 / rollSpeed,
					easing: tween.linear
				});
			}
		}
		if (bounds.right >= 2048) {
			self.x = 2048 - bounds.radius;
			self.velocityX = -Math.abs(self.velocityX) * self.bounceForce;
			bounced = true;
			// Add rolling animation when bouncing off right wall
			if (Math.abs(self.velocityX) > 0.1) {
				var rollSpeed = Math.abs(self.velocityX) * 0.1;
				tween(graphics, {
					rotation: graphics.rotation - Math.PI * 2
				}, {
					duration: 1000 / rollSpeed,
					easing: tween.linear
				});
			}
		}
		if (bounds.top <= 0) {
			self.y = bounds.radius;
			self.velocityY = Math.abs(self.velocityY) * self.bounceForce;
			bounced = true;
		}
		// Ground collision instead of bottom screen edge
		if (bounds.bottom >= groundLevel) {
			self.y = groundLevel - bounds.radius;
			self.velocityY = -Math.abs(self.velocityY) * self.bounceForce;
			bounced = true;
			// Add rolling animation when hitting ground
			if (Math.abs(self.velocityX) > 0.1) {
				var rollDirection = self.velocityX > 0 ? 1 : -1;
				var rollSpeed = Math.abs(self.velocityX) * 0.1;
				tween(graphics, {
					rotation: graphics.rotation + rollDirection * Math.PI * 2
				}, {
					duration: 1000 / rollSpeed,
					easing: tween.linear
				});
			}
		}
		if (bounced) {
			LK.getSound('bounce').play();
		}
	};
	return self;
});
var GoldenBerry = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('goldenBerry', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.floatOffset = Math.random() * Math.PI * 2;
	self.floatSpeed = 0.05;
	self.startY = 0;
	self.update = function () {
		self.y = self.startY + Math.sin(LK.ticks * self.floatSpeed + self.floatOffset) * 10;
	};
	return self;
});
var RedThorn = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('redThorn', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.rotation = Math.PI / 4;
	self.pulseOffset = Math.random() * Math.PI * 2;
	self.pulseSpeed = 0.08;
	self.update = function () {
		var pulse = 1 + Math.sin(LK.ticks * self.pulseSpeed + self.pulseOffset) * 0.1;
		graphics.scaleX = pulse;
		graphics.scaleY = pulse;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var blueberry = game.addChild(new Blueberry());
blueberry.x = 1024;
blueberry.y = 1366;
var goldenBerries = [];
var redThorns = [];
var dragNode = null;
var lastMouseX = 0;
var lastMouseY = 0;
var thornSpawnTimer = 0;
var berrySpawnTimer = 0;
var gravity = 0.8;
var groundLevel = 2632; // 100px from bottom of screen
var scoreTxt = new Text2('0', {
	size: 120,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
function spawnGoldenBerry() {
	var berry = new GoldenBerry();
	var margin = 50;
	berry.x = margin + Math.random() * (2048 - margin * 2);
	berry.y = margin + Math.random() * (groundLevel - margin * 2);
	berry.startY = berry.y;
	var tooClose = true;
	var attempts = 0;
	while (tooClose && attempts < 20) {
		tooClose = false;
		var berryBounds = {
			x: berry.x,
			y: berry.y,
			radius: 20
		};
		var blueberryBounds = blueberry.getBounds();
		var dist = Math.sqrt(Math.pow(berry.x - blueberry.x, 2) + Math.pow(berry.y - blueberry.y, 2));
		if (dist < blueberryBounds.radius + 100) {
			berry.x = margin + Math.random() * (2048 - margin * 2);
			berry.y = margin + Math.random() * (groundLevel - margin * 2);
			berry.startY = berry.y;
			tooClose = true;
		}
		// Check distance from all red thorns
		for (var k = 0; k < redThorns.length; k++) {
			var thornDist = Math.sqrt(Math.pow(berry.x - redThorns[k].x, 2) + Math.pow(berry.y - redThorns[k].y, 2));
			if (thornDist < 120) {
				berry.x = margin + Math.random() * (2048 - margin * 2);
				berry.y = margin + Math.random() * (groundLevel - margin * 2);
				berry.startY = berry.y;
				tooClose = true;
				break;
			}
		}
		attempts++;
	}
	goldenBerries.push(berry);
	game.addChild(berry);
}
function spawnRedThorn() {
	var thorn = new RedThorn();
	var margin = 50;
	thorn.x = margin + Math.random() * (2048 - margin * 2);
	thorn.y = margin + Math.random() * (groundLevel - margin * 2);
	var tooClose = true;
	var attempts = 0;
	while (tooClose && attempts < 15) {
		tooClose = false;
		var blueberryBounds = blueberry.getBounds();
		var dist = Math.sqrt(Math.pow(thorn.x - blueberry.x, 2) + Math.pow(thorn.y - blueberry.y, 2));
		if (dist < blueberryBounds.radius + 200) {
			thorn.x = margin + Math.random() * (2048 - margin * 2);
			thorn.y = margin + Math.random() * (groundLevel - margin * 2);
			tooClose = true;
		}
		attempts++;
	}
	redThorns.push(thorn);
	game.addChild(thorn);
}
function handleMove(x, y, obj) {
	if (dragNode) {
		var deltaX = x - lastMouseX;
		var deltaY = y - lastMouseY;
		// Instead of teleporting, smoothly move towards target position
		var targetX = x;
		var targetY = y;
		var currentX = dragNode.x;
		var currentY = dragNode.y;
		// Smooth interpolation towards target position
		var lerpFactor = 0.15;
		dragNode.x = currentX + (targetX - currentX) * lerpFactor;
		dragNode.y = currentY + (targetY - currentY) * lerpFactor;
		dragNode.velocityX = deltaX * 0.3;
		dragNode.velocityY = deltaY * 0.3;
	}
	lastMouseX = x;
	lastMouseY = y;
}
game.move = handleMove;
game.down = function (x, y, obj) {
	dragNode = blueberry;
	lastMouseX = x;
	lastMouseY = y;
	handleMove(x, y, obj);
};
game.up = function (x, y, obj) {
	if (dragNode) {
		// Calculate throw velocity based on drag distance and speed
		var throwMultiplier = 0.5;
		var maxThrowSpeed = 15;
		// Use the current velocity from dragging as throw velocity
		var throwVelX = Math.max(-maxThrowSpeed, Math.min(maxThrowSpeed, dragNode.velocityX * throwMultiplier));
		var throwVelY = Math.max(-maxThrowSpeed, Math.min(maxThrowSpeed, dragNode.velocityY * throwMultiplier));
		// Apply the throw velocity to the blueberry
		dragNode.velocityX = throwVelX;
		dragNode.velocityY = throwVelY;
		// Add throwing visual effects
		var throwPower = Math.sqrt(throwVelX * throwVelX + throwVelY * throwVelY);
		if (throwPower > 2) {
			// Scale effect - squeeze and stretch for impact
			var blueberryGraphics = dragNode.children[0];
			tween(blueberryGraphics, {
				scaleX: 1.3,
				scaleY: 0.7
			}, {
				duration: 100,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(blueberryGraphics, {
						scaleX: dragNode.growthFactor,
						scaleY: dragNode.growthFactor
					}, {
						duration: 200,
						easing: tween.elasticOut
					});
				}
			});
			// Create trail effect with multiple afterimages
			for (var t = 0; t < 5; t++) {
				var trail = game.addChild(LK.getAsset('blueberry', {
					anchorX: 0.5,
					anchorY: 0.5
				}));
				trail.x = dragNode.x;
				trail.y = dragNode.y;
				trail.scaleX = dragNode.growthFactor * (0.8 - t * 0.1);
				trail.scaleY = dragNode.growthFactor * (0.8 - t * 0.1);
				trail.alpha = 0.6 - t * 0.1;
				trail.tint = 0x88AAFF;
				// Animate trail fade out and slight movement
				tween(trail, {
					alpha: 0,
					scaleX: trail.scaleX * 0.5,
					scaleY: trail.scaleY * 0.5,
					x: trail.x - throwVelX * (t + 1) * 0.5,
					y: trail.y - throwVelY * (t + 1) * 0.5
				}, {
					duration: 300 + t * 100,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						trail.destroy();
					}
				});
			}
			// Flash effect for powerful throws
			if (throwPower > 8) {
				LK.effects.flashObject(dragNode, 0xFFFFFF, 200);
			}
		}
	}
	dragNode = null;
};
// Create ground visual
var ground = game.addChild(LK.getAsset('ground', {
	anchorX: 0,
	anchorY: 0
}));
ground.x = 0;
ground.y = groundLevel;
spawnGoldenBerry();
spawnGoldenBerry();
spawnGoldenBerry();
game.update = function () {
	berrySpawnTimer++;
	thornSpawnTimer++;
	if (berrySpawnTimer > 150 && goldenBerries.length < 5) {
		spawnGoldenBerry();
		berrySpawnTimer = 0;
	}
	var thornSpawnRate = Math.max(360 - Math.floor(LK.getScore() * 3), 120);
	if (thornSpawnTimer > thornSpawnRate) {
		spawnRedThorn();
		thornSpawnTimer = 0;
	}
	var blueberryBounds = blueberry.getBounds();
	for (var i = goldenBerries.length - 1; i >= 0; i--) {
		var berry = goldenBerries[i];
		var dist = Math.sqrt(Math.pow(berry.x - blueberry.x, 2) + Math.pow(berry.y - blueberry.y, 2));
		if (dist < blueberryBounds.radius + 20) {
			LK.setScore(LK.getScore() + 1);
			scoreTxt.setText(LK.getScore());
			blueberry.grow();
			LK.getSound('collect').play();
			LK.effects.flashObject(berry, 0xFFFFFF, 200);
			berry.destroy();
			goldenBerries.splice(i, 1);
			if (LK.getScore() >= 100) {
				LK.showYouWin();
			}
		}
	}
	for (var j = 0; j < redThorns.length; j++) {
		var thorn = redThorns[j];
		var dist = Math.sqrt(Math.pow(thorn.x - blueberry.x, 2) + Math.pow(thorn.y - blueberry.y, 2));
		if (dist < blueberryBounds.radius + 20) {
			LK.effects.flashScreen(0xFF0000, 1000);
			LK.showGameOver();
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -262,8 +262,61 @@
 		var throwVelY = Math.max(-maxThrowSpeed, Math.min(maxThrowSpeed, dragNode.velocityY * throwMultiplier));
 		// Apply the throw velocity to the blueberry
 		dragNode.velocityX = throwVelX;
 		dragNode.velocityY = throwVelY;
+		// Add throwing visual effects
+		var throwPower = Math.sqrt(throwVelX * throwVelX + throwVelY * throwVelY);
+		if (throwPower > 2) {
+			// Scale effect - squeeze and stretch for impact
+			var blueberryGraphics = dragNode.children[0];
+			tween(blueberryGraphics, {
+				scaleX: 1.3,
+				scaleY: 0.7
+			}, {
+				duration: 100,
+				easing: tween.easeOut,
+				onFinish: function onFinish() {
+					tween(blueberryGraphics, {
+						scaleX: dragNode.growthFactor,
+						scaleY: dragNode.growthFactor
+					}, {
+						duration: 200,
+						easing: tween.elasticOut
+					});
+				}
+			});
+			// Create trail effect with multiple afterimages
+			for (var t = 0; t < 5; t++) {
+				var trail = game.addChild(LK.getAsset('blueberry', {
+					anchorX: 0.5,
+					anchorY: 0.5
+				}));
+				trail.x = dragNode.x;
+				trail.y = dragNode.y;
+				trail.scaleX = dragNode.growthFactor * (0.8 - t * 0.1);
+				trail.scaleY = dragNode.growthFactor * (0.8 - t * 0.1);
+				trail.alpha = 0.6 - t * 0.1;
+				trail.tint = 0x88AAFF;
+				// Animate trail fade out and slight movement
+				tween(trail, {
+					alpha: 0,
+					scaleX: trail.scaleX * 0.5,
+					scaleY: trail.scaleY * 0.5,
+					x: trail.x - throwVelX * (t + 1) * 0.5,
+					y: trail.y - throwVelY * (t + 1) * 0.5
+				}, {
+					duration: 300 + t * 100,
+					easing: tween.easeOut,
+					onFinish: function onFinish() {
+						trail.destroy();
+					}
+				});
+			}
+			// Flash effect for powerful throws
+			if (throwPower > 8) {
+				LK.effects.flashObject(dragNode, 0xFFFFFF, 200);
+			}
+		}
 	}
 	dragNode = null;
 };
 // Create ground visual