/**** 
* Classes
****/ 
var Arrow = Container.expand(function (targetX, targetY, startX, startY) {
	var self = Container.call(this);
	// Attach arrow asset
	var arrowGraphics = self.attachAsset('arrow', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Calculate direction and speed
	var dx = targetX - startX;
	var dy = targetY - startY;
	var distance = Math.sqrt(dx * dx + dy * dy);
	var speed = 8;
	self.velocityX = dx / distance * speed;
	self.velocityY = dy / distance * speed;
	// Set rotation to point toward target
	arrowGraphics.rotation = Math.atan2(dy, dx);
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Remove arrow if it goes off screen (check this first for early exit)
		if (self.x < -100 || self.x > 2148 || self.y < -100 || self.y > 2832) {
			self.destroy();
			return;
		}
		// Only check collisions if arrow is in reasonable range
		var collisionRange = 200;
		var arrowBounds = {
			left: self.x - collisionRange,
			right: self.x + collisionRange,
			top: self.y - collisionRange,
			bottom: self.y + collisionRange
		};
		// Check collision with balls (with bounds optimization)
		for (var i = balls.length - 1; i >= 0; i--) {
			var ball = balls[i];
			// Quick bounds check before expensive intersection test
			if (ball.x >= arrowBounds.left && ball.x <= arrowBounds.right && ball.y >= arrowBounds.top && ball.y <= arrowBounds.bottom) {
				if (self.intersects(ball)) {
					// Trigger ball hit
					ball.hit();
					self.destroy();
					return;
				}
			}
		}
		// Check collision with bombs (with bounds optimization)
		for (var j = bombs.length - 1; j >= 0; j--) {
			var bomb = bombs[j];
			// Quick bounds check before expensive intersection test
			if (bomb.x >= arrowBounds.left && bomb.x <= arrowBounds.right && bomb.y >= arrowBounds.top && bomb.y <= arrowBounds.bottom) {
				if (self.intersects(bomb)) {
					// Trigger bomb hit
					bomb.hit();
					self.destroy();
					return;
				}
			}
		}
	};
	return self;
});
var Ball = Container.expand(function (ballType) {
	var self = Container.call(this);
	// Store ball type and set properties based on type
	self.ballType = ballType;
	var assetId, points;
	switch (ballType) {
		case 'red':
			assetId = 'redBall';
			points = 40;
			break;
		case 'yellow':
			assetId = 'yellowBall';
			points = 60;
			break;
		case 'blue':
			assetId = 'blueBall';
			points = 70;
			break;
	}
	self.points = points;
	// Attach the appropriate ball asset
	var ballGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add floating animation
	self.floatDirection = Math.random() > 0.5 ? 1 : -1;
	self.floatSpeed = 0.5 + Math.random() * 0.5;
	self.floatOffset = 0;
	// Add horizontal movement
	self.horizontalDirection = Math.random() > 0.5 ? 1 : -1;
	self.horizontalSpeed = 4 + Math.random() * 3;
	// Add vertical movement
	self.verticalDirection = Math.random() > 0.5 ? 1 : -1;
	self.verticalSpeed = 1.5 + Math.random() * 2;
	self.update = function () {
		// Only update floating animation every few frames to reduce CPU load
		if (LK.ticks % 3 === 0) {
			self.floatOffset += self.floatSpeed;
			self.y += Math.sin(self.floatOffset) * self.floatDirection * 0.3;
		}
		// Add horizontal movement
		self.x += self.horizontalSpeed * self.horizontalDirection;
		// Add vertical movement
		self.y += self.verticalSpeed * self.verticalDirection;
		// Bounce off screen edges - keep balls in central area
		if (self.x <= 300 || self.x >= 1748) {
			self.horizontalDirection *= -1;
		}
		// Bounce off top and bottom edges but allow movement to lower areas
		if (self.y <= 150 || self.y >= 2200) {
			self.verticalDirection *= -1;
		}
	};
	self.hit = function () {
		// Award points and remove ball
		LK.setScore(LK.getScore() + self.points);
		scoreTxt.setText(LK.getScore());
		LK.getSound('pop').play();
		// Remove from balls array
		for (var i = balls.length - 1; i >= 0; i--) {
			if (balls[i] === self) {
				balls.splice(i, 1);
				break;
			}
		}
		// Spawn a new random ball at a random position
		var randomBallType = ballTypes[Math.floor(Math.random() * ballTypes.length)];
		var newBall = new Ball(randomBallType);
		// Random position in the game area (avoiding edges)
		newBall.x = 150 + Math.random() * (2048 - 300);
		newBall.y = 200 + Math.random() * 800;
		balls.push(newBall);
		game.addChild(newBall);
		self.destroy();
	};
	return self;
});
var Bomb = Container.expand(function () {
	var self = Container.call(this);
	// Attach bomb asset
	var bombGraphics = self.attachAsset('bomb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add pulsing animation to make it look dangerous
	self.pulseOffset = Math.random() * Math.PI * 2;
	// Add horizontal movement
	self.horizontalDirection = Math.random() > 0.5 ? 1 : -1;
	self.horizontalSpeed = 4 + Math.random() * 3;
	// Add vertical movement
	self.verticalDirection = Math.random() > 0.5 ? 1 : -1;
	self.verticalSpeed = 1.5 + Math.random() * 2;
	self.update = function () {
		// Only update pulsing animation every few frames to reduce CPU load
		if (LK.ticks % 2 === 0) {
			self.pulseOffset += 0.1;
			var scale = 1 + Math.sin(self.pulseOffset) * 0.1;
			bombGraphics.scaleX = scale;
			bombGraphics.scaleY = scale;
		}
		// Add horizontal movement
		self.x += self.horizontalSpeed * self.horizontalDirection;
		// Add vertical movement
		self.y += self.verticalSpeed * self.verticalDirection;
		// Bounce off screen edges - keep bombs in central area
		if (self.x <= 300 || self.x >= 1748) {
			self.horizontalDirection *= -1;
		}
		// Bounce off top and bottom edges but allow movement to lower areas
		if (self.y <= 150 || self.y >= 2200) {
			self.verticalDirection *= -1;
		}
	};
	self.hit = function () {
		// Play bomb sound effect
		LK.getSound('bombSound').play();
		// Deduct points and lose a life for hitting bomb
		LK.setScore(Math.max(0, LK.getScore() - 30));
		scoreTxt.setText(LK.getScore());
		lives--;
		updateHeartsDisplay();
		bombHitCount++;
		// Flash screen red to indicate penalty
		LK.effects.flashScreen(0xff0000, 500);
		// Check if 5 bombs hit - restart game
		if (bombHitCount >= 5) {
			LK.showGameOver();
			return;
		}
		// Check game over
		if (lives <= 0) {
			LK.showGameOver();
		}
		// Remove from bombs array
		for (var i = bombs.length - 1; i >= 0; i--) {
			if (bombs[i] === self) {
				bombs.splice(i, 1);
				break;
			}
		}
		self.destroy();
	};
	return self;
});

/**** 
* Initialize Game
****/ 
// Game arrays to track objects
var game = new LK.Game({
	backgroundColor: 0x001122
});

/**** 
* Game Code
****/ 
// Initialize ball assets with different colors
// Game arrays to track objects
var balls = [];
var bombs = [];
var lives = 5;
var hearts = [];
var bombHitCount = 0;
// Score display
var scoreTxt = new Text2('0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(1, 0);
scoreTxt.x = -20;
scoreTxt.y = 20;
LK.gui.topRight.addChild(scoreTxt);
// Initialize hearts display
function updateHeartsDisplay() {
	// Clear existing hearts
	for (var h = 0; h < hearts.length; h++) {
		hearts[h].destroy();
	}
	hearts = [];
	// Create new hearts based on current lives
	for (var i = 0; i < lives; i++) {
		var heart = LK.getAsset('heart', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		heart.x = -120 - i * 70;
		heart.y = -120;
		LK.gui.bottomRight.addChild(heart);
		hearts.push(heart);
	}
}
// Initialize hearts display
updateHeartsDisplay();
// Ball types for spawning
var ballTypes = ['red', 'yellow', 'blue'];
// Create initial grid of balls and bombs arranged side by side
var currentX = 120;
var currentY = 200;
var itemsPerRow = 10;
var spacing = 150;
var itemCount = 0;
// Create equal amounts of balls and bombs in a grid
for (var row = 0; row < 8; row++) {
	for (var col = 0; col < itemsPerRow; col++) {
		var x = currentX + col * spacing;
		var y = currentY + row * spacing;
		if (itemCount % 6 === 5) {
			// Every 6th item is a bomb
			var bomb = new Bomb();
			bomb.x = x;
			bomb.y = y;
			bombs.push(bomb);
			game.addChild(bomb);
		} else {
			// Create balls in sequence: red, yellow, blue
			var ballType = ballTypes[itemCount % 3];
			var ball = new Ball(ballType);
			ball.x = x;
			ball.y = y;
			balls.push(ball);
			game.addChild(ball);
		}
		itemCount++;
	}
}
// Create hand launcher at bottom center
var hand = game.addChild(LK.getAsset('hand', {
	anchorX: 0.5,
	anchorY: 0.5
}));
hand.x = 1024;
hand.y = 2500;
var isDragging = false;
var dragStartX = 0;
var dragStartY = 0;
game.down = function (x, y, obj) {
	// Check if touch is near the hand
	var distance = Math.sqrt((x - hand.x) * (x - hand.x) + (y - hand.y) * (y - hand.y));
	if (distance < 100) {
		isDragging = true;
		dragStartX = x;
		dragStartY = y;
	}
};
game.move = function (x, y, obj) {
	if (isDragging) {
		// Move hand slightly toward drag direction
		var dx = x - dragStartX;
		var dy = y - dragStartY;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 10) {
			// Limit movement to 3 steps (90 pixels) from center
			var maxDistance = 90;
			var targetX = 1024 + dx * 0.3;
			var targetY = 2500 + dy * 0.3;
			var distanceFromCenter = Math.sqrt((targetX - 1024) * (targetX - 1024) + (targetY - 2500) * (targetY - 2500));
			if (distanceFromCenter > maxDistance) {
				var ratio = maxDistance / distanceFromCenter;
				targetX = 1024 + (targetX - 1024) * ratio;
				targetY = 2500 + (targetY - 2500) * ratio;
			}
			hand.x = targetX;
			hand.y = targetY;
		}
	}
};
game.up = function (x, y, obj) {
	if (isDragging) {
		// Calculate launch direction (upward from hand position)
		var dx = x - hand.x;
		var dy = y - hand.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 20) {
			// Create and launch arrow toward touch point
			var arrow = new Arrow(x, y, hand.x, hand.y);
			arrow.x = hand.x;
			arrow.y = hand.y;
			game.addChild(arrow);
		}
		// Reset hand position
		hand.x = 1024;
		hand.y = 2500;
		isDragging = false;
	}
};
// Play background music
LK.playMusic('J');
game.update = function () {
	// Score is updated only when it changes in Ball.hit() and Bomb.hit()
	// No need for redundant updates here
};

===================================================================
--- original.js
+++ change.js
@@ -106,10 +106,10 @@
 		// Add horizontal movement
 		self.x += self.horizontalSpeed * self.horizontalDirection;
 		// Add vertical movement
 		self.y += self.verticalSpeed * self.verticalDirection;
-		// Bounce off screen edges
-		if (self.x <= 60 || self.x >= 1988) {
+		// Bounce off screen edges - keep balls in central area
+		if (self.x <= 300 || self.x >= 1748) {
 			self.horizontalDirection *= -1;
 		}
 		// Bounce off top and bottom edges but allow movement to lower areas
 		if (self.y <= 150 || self.y >= 2200) {
@@ -166,10 +166,10 @@
 		// Add horizontal movement
 		self.x += self.horizontalSpeed * self.horizontalDirection;
 		// Add vertical movement
 		self.y += self.verticalSpeed * self.verticalDirection;
-		// Bounce off screen edges
-		if (self.x <= 50 || self.x >= 1998) {
+		// Bounce off screen edges - keep bombs in central area
+		if (self.x <= 300 || self.x >= 1748) {
 			self.horizontalDirection *= -1;
 		}
 		// Bounce off top and bottom edges but allow movement to lower areas
 		if (self.y <= 150 || self.y >= 2200) {