/**** 
* 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 = 1.2;
	self.lastBounced = false;
	self.bounceCooldown = 0;
	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.2;
				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;
			// Create dust particles when hitting ground with significant velocity
			if (Math.abs(self.velocityY) > 3 || Math.abs(self.velocityX) > 3) {
				for (var d = 0; d < 5; d++) {
					createDustParticle(self.x, groundLevel);
				}
			}
			// Stop trailing when landing
			if (isTrailing && Math.abs(self.velocityY) < 2 && Math.abs(self.velocityX) < 2) {
				isTrailing = false;
			}
			// 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
				});
			}
		}
		// Create trail particles when moving fast
		if (isTrailing && (Math.abs(self.velocityX) > 1 || Math.abs(self.velocityY) > 1)) {
			if (LK.ticks % 3 === 0) {
				// Create particle every 3 frames
				createTrailParticle(self.x, self.y);
			}
		}
		// Update bounce cooldown
		if (self.bounceCooldown > 0) {
			self.bounceCooldown--;
		}
		// Only play bounce sound when transitioning from not bounced to bounced
		// and cooldown has expired and there's significant velocity
		if (bounced && !self.lastBounced && self.bounceCooldown === 0 && (Math.abs(self.velocityX) > 2 || Math.abs(self.velocityY) > 2)) {
			LK.getSound('bounce').play();
			self.bounceCooldown = 1; // 1 frames cooldown (~0.33 seconds at 60fps)
		}
		self.lastBounced = bounced;
	};
	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 / 1;
	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: 0x9edbf3
});

/**** 
* 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 trailParticles = [];
var isTrailing = false;
function createTrailParticle(x, y) {
	var particle = LK.getAsset('blueberry', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.3,
		scaleY: 0.3,
		alpha: 0.8
	});
	particle.x = x;
	particle.y = y;
	particle.life = 30; // frames to live
	particle.maxLife = 30;
	trailParticles.push(particle);
	game.addChild(particle);
}
var dustParticles = [];
function createDustParticle(x, y) {
	var particle = LK.getAsset('blueberry', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.2,
		scaleY: 0.2,
		alpha: 0.6,
		tint: 0xD2B48C
	});
	particle.x = x + (Math.random() - 0.5) * 60;
	particle.y = y;
	particle.velocityX = (Math.random() - 0.5) * 4;
	particle.velocityY = -(Math.random() * 3 + 1);
	particle.life = 40;
	particle.maxLife = 40;
	dustParticles.push(particle);
	game.addChild(particle);
}
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;
			}
			// Update trail particles
			for (var t = trailParticles.length - 1; t >= 0; t--) {
				var particle = trailParticles[t];
				particle.life--;
				// Fade out particle
				particle.alpha = particle.life / particle.maxLife * 0.2;
				particle.scaleX = particle.life / particle.maxLife * 0.1;
				particle.scaleY = particle.life / particle.maxLife * 0.1;
				// Remove dead particles
				if (particle.life <= 0) {
					particle.destroy();
					trailParticles.splice(t, 1);
				}
			}
		}
		;
		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;
		// Start trailing effect if there's significant velocity
		if (Math.abs(throwVelX) > 2 || Math.abs(throwVelY) > 2) {
			isTrailing = true;
		}
		// Add throwing effect - scale bounce animation
		var blueberryGraphics = dragNode.children[0]; // Get the graphics child
		var currentGrowthFactor = dragNode.growthFactor; // Store growth factor before clearing dragNode
		if (blueberryGraphics) {
			// Stop any existing scale tweens
			tween.stop(blueberryGraphics, {
				scaleX: true,
				scaleY: true
			});
			// Create throwing effect with scale bounce
			tween(blueberryGraphics, {
				scaleX: currentGrowthFactor * 1.3,
				scaleY: currentGrowthFactor * 1.3
			}, {
				duration: 150,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(blueberryGraphics, {
						scaleX: currentGrowthFactor,
						scaleY: currentGrowthFactor
					}, {
						duration: 200,
						easing: tween.easeInOut
					});
				}
			});
		}
	}
	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();
		}
	}
	// Update dust particles
	for (var d = dustParticles.length - 1; d >= 0; d--) {
		var dustParticle = dustParticles[d];
		dustParticle.x += dustParticle.velocityX;
		dustParticle.y += dustParticle.velocityY;
		dustParticle.velocityX *= 0.98;
		dustParticle.velocityY += 0.1; // gravity
		dustParticle.life--;
		// Fade out dust particle
		dustParticle.alpha = dustParticle.life / dustParticle.maxLife * 0.6;
		dustParticle.scaleX = dustParticle.life / dustParticle.maxLife * 0.2;
		dustParticle.scaleY = dustParticle.life / dustParticle.maxLife * 0.2;
		// Remove dead dust particles
		if (dustParticle.life <= 0) {
			dustParticle.destroy();
			dustParticles.splice(d, 1);
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -127,9 +127,9 @@
 		// Only play bounce sound when transitioning from not bounced to bounced
 		// and cooldown has expired and there's significant velocity
 		if (bounced && !self.lastBounced && self.bounceCooldown === 0 && (Math.abs(self.velocityX) > 2 || Math.abs(self.velocityY) > 2)) {
 			LK.getSound('bounce').play();
-			self.bounceCooldown = 20; // 20 frames cooldown (~0.33 seconds at 60fps)
+			self.bounceCooldown = 1; // 1 frames cooldown (~0.33 seconds at 60fps)
 		}
 		self.lastBounced = bounced;
 	};
 	return self;