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

/**** 
* Classes
****/ 
var Ball = Container.expand(function () {
	var self = Container.call(this);
	var ballGraphics = self.attachAsset('ball', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.9
	});
	var glowBall = self.attachAsset('ball', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.4,
		scaleX: 1.5,
		scaleY: 1.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.speed = 10;
	self.gravityAffected = true;
	self.reset = function () {
		self.x = 2048 / 2;
		self.y = 2732 / 2;
		self.velocityX = (Math.random() > 0.5 ? 1 : -1) * self.speed;
		self.velocityY = (Math.random() * 2 - 1) * self.speed * 0.5;
		// Add pulsating glow effect
		self.startGlowAnimation();
	};
	self.startGlowAnimation = function () {
		tween(glowBall.scale, {
			x: 1.8,
			y: 1.8
		}, {
			duration: 800,
			easing: tween.sinceOut,
			onFinish: function onFinish() {
				tween(glowBall.scale, {
					x: 1.5,
					y: 1.5
				}, {
					duration: 800,
					easing: tween.sinceIn,
					onFinish: function onFinish() {
						self.startGlowAnimation();
					}
				});
			}
		});
	};
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Handle wall collisions
		if (self.x < 0 + ballGraphics.width / 2) {
			self.x = ballGraphics.width / 2;
			self.velocityX = -self.velocityX;
		} else if (self.x > 2048 - ballGraphics.width / 2) {
			self.x = 2048 - ballGraphics.width / 2;
			self.velocityX = -self.velocityX;
		}
	};
	return self;
});
var GravityField = Container.expand(function () {
	var self = Container.call(this);
	var fieldGraphics = self.attachAsset('gravitationField', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.2
	});
	self.strength = 0.1;
	self.maxStrength = 0.5;
	self.setup = function () {
		self.x = 2048 / 2;
		self.y = 2732 / 2;
		self.strength = 0.1;
		self.scale.set(1);
	};
	self.increaseStrength = function () {
		self.strength = Math.min(self.maxStrength, self.strength + 0.05);
		tween(self.scale, {
			x: 1 + self.strength,
			y: 1 + self.strength
		}, {
			duration: 1000,
			easing: tween.elasticOut
		});
	};
	self.reverseGravity = function () {
		self.strength = -self.strength;
		tween(fieldGraphics, {
			tint: 0xFF5733
		}, {
			duration: 300,
			easing: tween.linear,
			onFinish: function onFinish() {
				tween(fieldGraphics, {
					tint: 0x4287f5
				}, {
					duration: 5000,
					easing: tween.linear,
					onFinish: function onFinish() {
						self.strength = Math.abs(self.strength);
					}
				});
			}
		});
	};
	self.applyGravityTo = function (ball) {
		if (!ball.gravityAffected) {
			return;
		}
		var dx = self.x - ball.x;
		var dy = self.y - ball.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 10) {
			var forceX = dx / distance * self.strength;
			var forceY = dy / distance * self.strength;
			ball.velocityX += forceX;
			ball.velocityY += forceY;
			// Cap maximum velocity
			var speed = Math.sqrt(ball.velocityX * ball.velocityX + ball.velocityY * ball.velocityY);
			if (speed > ball.speed * 2) {
				ball.velocityX = ball.velocityX / speed * ball.speed * 2;
				ball.velocityY = ball.velocityY / speed * ball.speed * 2;
			}
		}
	};
	return self;
});
var Paddle = Container.expand(function () {
	var self = Container.call(this);
	// Create shadow effect
	var paddleShadow = self.attachAsset('paddle', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.3,
		scaleX: 1.05,
		scaleY: 1.8,
		y: 8
	});
	var paddleGraphics = self.attachAsset('paddle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.targetX = 0;
	self.speed = 15;
	self.isPlayer = false;
	self.score = 0;
	self.setup = function (isPlayer) {
		self.isPlayer = isPlayer;
		if (isPlayer) {
			self.y = 2732 - 200;
			paddleGraphics.tint = 0x4287f5; // Blue for player
		} else {
			self.y = 200;
			paddleGraphics.tint = 0xff5733; // Orange for AI
		}
		self.x = 2048 / 2;
		self.targetX = self.x;
		// Create entrance animation
		self.scale.set(0.1);
		tween(self.scale, {
			x: 1,
			y: 1
		}, {
			duration: 800,
			easing: tween.elasticOut
		});
	};
	self.update = function () {
		// Move toward target position with easing
		if (Math.abs(self.x - self.targetX) > 1) {
			self.x += (self.targetX - self.x) * 0.2;
		}
		// Boundary check
		if (self.x < paddleGraphics.width / 2) {
			self.x = paddleGraphics.width / 2;
		} else if (self.x > 2048 - paddleGraphics.width / 2) {
			self.x = 2048 - paddleGraphics.width / 2;
		}
	};
	return self;
});
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var type = 'gravity'; // Default type
	var powerUpGraphics;
	self.setup = function (powerType) {
		type = powerType;
		if (self.children.length > 0) {
			self.removeChildAt(0);
		}
		if (type === 'gravity') {
			powerUpGraphics = self.attachAsset('powerUpGravity', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'multiball') {
			powerUpGraphics = self.attachAsset('powerUpMultiBall', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
		self.x = Math.random() * (2048 - 200) + 100;
		self.y = Math.random() * (2732 - 600) + 300;
		self.alpha = 1;
		// Pulsating animation
		tween(self, {
			alpha: 0.6
		}, {
			duration: 800,
			easing: tween.sinceOut,
			onFinish: function onFinish() {
				tween(self, {
					alpha: 1
				}, {
					duration: 800,
					easing: tween.sinceIn,
					onFinish: function onFinish() {
						if (self.parent) {
							self.setup(type);
						}
					}
				});
			}
		});
	};
	self.getType = function () {
		return type;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Set a beautiful dark gradient background
game.setBackgroundColor(0x0a0a2a);
// Create a star field background
function createStarfield() {
	var starfield = new Container();
	// Create stars with different sizes and opacities
	for (var i = 0; i < 100; i++) {
		var size = Math.random() * 4 + 1;
		var star = LK.getAsset('ball', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: size,
			height: size,
			alpha: Math.random() * 0.7 + 0.3
		});
		star.x = Math.random() * 2048;
		star.y = Math.random() * 2732;
		// Create twinkling animation
		var duration = Math.random() * 3000 + 2000;
		// Create closure to keep reference to the current star
		(function (starElement) {
			function animateStar() {
				tween(starElement, {
					alpha: Math.random() * 0.5 + 0.1
				}, {
					duration: duration,
					easing: tween.sinceInOut,
					onFinish: function onFinish() {
						tween(starElement, {
							alpha: Math.random() * 0.7 + 0.3
						}, {
							duration: duration,
							easing: tween.sinceInOut,
							onFinish: animateStar
						});
					}
				});
			}
			animateStar();
		})(star);
		starfield.addChild(star);
	}
	game.addChildAt(starfield, 0); // Add at the bottom layer
	return starfield;
}
// Create starfield
var starfield = createStarfield();
// Create game elements
var playerPaddle = new Paddle();
var aiPaddle = new Paddle();
var gravityField = new GravityField();
var balls = [];
var powerUps = [];
var centerLine;
var playerScoreText;
var aiScoreText;
var dragTarget = null;
var difficultyTimer;
var powerUpTimer;
var gameActive = false;
// Animate score text function
function animateScoreText(textObject, newValue) {
	// Store original scale
	var originalScale = {
		x: textObject.scale.x,
		y: textObject.scale.y
	};
	// Set the new text
	textObject.setText(newValue);
	// Animate scale up and back down
	tween.stop(textObject.scale);
	textObject.scale.set(originalScale.x * 1.5, originalScale.y * 1.5);
	tween(textObject.scale, {
		x: originalScale.x,
		y: originalScale.y
	}, {
		duration: 500,
		easing: tween.elasticOut
	});
}
// Initialize game state
function initGame() {
	// Setup players
	playerPaddle.setup(true);
	aiPaddle.setup(false);
	game.addChild(playerPaddle);
	game.addChild(aiPaddle);
	// Setup gravity field
	gravityField.setup();
	game.addChild(gravityField);
	// Create center line with animation
	centerLine = new Container();
	centerLine.alpha = 0;
	for (var i = 0; i < 20; i++) {
		var dash = LK.getAsset('paddle', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 50,
			height: 10,
			alpha: 0.5
		});
		dash.x = i * 110;
		// Add staggered animation to each dash
		(function (element, delay) {
			element.alpha = 0;
			element.scale.set(0.5);
			LK.setTimeout(function () {
				tween(element, {
					alpha: 0.5
				}, {
					duration: 400,
					easing: tween.linear
				});
				tween(element.scale, {
					x: 1,
					y: 1
				}, {
					duration: 600,
					easing: tween.elasticOut
				});
			}, delay);
		})(dash, i * 30);
		centerLine.addChild(dash);
	}
	centerLine.x = 50;
	centerLine.y = 2732 / 2;
	game.addChild(centerLine);
	tween(centerLine, {
		alpha: 1
	}, {
		duration: 800,
		easing: tween.linear
	});
	// Create score text with animated appearance
	playerScoreText = new Text2('0', {
		size: 150,
		fill: 0xFFFFFF
	});
	playerScoreText.anchor.set(0.5, 1);
	playerScoreText.x = 2048 / 2;
	playerScoreText.y = 2732 - 50;
	playerScoreText.alpha = 0;
	playerScoreText.scale.set(0.5);
	game.addChild(playerScoreText);
	aiScoreText = new Text2('0', {
		size: 150,
		fill: 0xFFFFFF
	});
	aiScoreText.anchor.set(0.5, 0);
	aiScoreText.x = 2048 / 2;
	aiScoreText.y = 50;
	aiScoreText.alpha = 0;
	aiScoreText.scale.set(0.5);
	game.addChild(aiScoreText);
	// Animate score text appearance
	tween(playerScoreText, {
		alpha: 1
	}, {
		duration: 800,
		easing: tween.linear
	});
	tween(playerScoreText.scale, {
		x: 1,
		y: 1
	}, {
		duration: 1000,
		easing: tween.elasticOut
	});
	tween(aiScoreText, {
		alpha: 1
	}, {
		duration: 800,
		easing: tween.linear
	});
	tween(aiScoreText.scale, {
		x: 1,
		y: 1
	}, {
		duration: 1000,
		easing: tween.elasticOut
	});
	// Create first ball with delay to allow UI elements to animate in
	LK.setTimeout(function () {
		createBall();
	}, 1200);
	// Setup difficulty increases
	difficultyTimer = LK.setInterval(function () {
		if (gameActive) {
			gravityField.increaseStrength();
		}
	}, 10000);
	// Setup power-up spawning
	powerUpTimer = LK.setInterval(function () {
		if (gameActive && powerUps.length < 1) {
			spawnPowerUp();
		}
	}, 15000);
	// Start game
	gameActive = true;
	LK.playMusic('gameMusic');
}
// Function to create a new ball
function createBall() {
	var ball = new Ball();
	ball.reset();
	balls.push(ball);
	game.addChild(ball);
	return ball;
}
// Function to spawn a power-up
function spawnPowerUp() {
	var powerUp = new PowerUp();
	var type = Math.random() > 0.5 ? 'gravity' : 'multiball';
	powerUp.setup(type);
	powerUps.push(powerUp);
	game.addChild(powerUp);
}
// Check for collisions between ball and paddle
function checkPaddleCollision(ball, paddle) {
	if (ball.y + 25 >= paddle.y - 25 && ball.y - 25 <= paddle.y + 25) {
		if (ball.x + 25 >= paddle.x - 125 && ball.x - 25 <= paddle.x + 125) {
			// Calculate bounce angle based on where ball hit the paddle
			var relativeIntersectX = ball.x - paddle.x;
			var normalizedRelativeIntersectionX = relativeIntersectX / 125;
			var bounceAngle = normalizedRelativeIntersectionX * (Math.PI / 3); // Maximum angle: 60 degrees
			// Invert Y velocity and adjust X velocity based on bounce angle
			ball.velocityY = -ball.velocityY;
			ball.velocityX = ball.speed * Math.sin(bounceAngle);
			// Increase speed slightly
			ball.speed = Math.min(20, ball.speed * 1.05);
			// Play bounce sound
			LK.getSound('bounce').play();
			// Enhanced paddle hit effect - scale and flash
			tween.stop(paddle.scale);
			paddle.scale.set(1.2, 0.8);
			tween(paddle.scale, {
				x: 1,
				y: 1
			}, {
				duration: 300,
				easing: tween.elasticOut
			});
			// Flash paddle with color based on player
			LK.effects.flashObject(paddle, paddle.isPlayer ? 0x4287f5 : 0xff5733, 300);
			return true;
		}
	}
	return false;
}
// Check for collisions between ball and power-up
function checkPowerUpCollision(ball) {
	for (var i = powerUps.length - 1; i >= 0; i--) {
		var powerUp = powerUps[i];
		if (ball.intersects(powerUp)) {
			// Create explosion effect at power-up location
			var explosionEffect = new Container();
			explosionEffect.x = powerUp.x;
			explosionEffect.y = powerUp.y;
			game.addChild(explosionEffect);
			// Create multiple particles for explosion
			for (var p = 0; p < 10; p++) {
				var particle = LK.getAsset(powerUp.getType() === 'gravity' ? 'powerUpGravity' : 'powerUpMultiBall', {
					anchorX: 0.5,
					anchorY: 0.5,
					scale: 0.5,
					alpha: 0.8
				});
				// Randomize particle position and movement
				var angle = Math.random() * Math.PI * 2;
				var distance = Math.random() * 100 + 50;
				var duration = Math.random() * 500 + 500;
				particle.x = 0;
				particle.y = 0;
				explosionEffect.addChild(particle);
				// Animate particle movement and fade
				tween(particle, {
					x: Math.cos(angle) * distance,
					y: Math.sin(angle) * distance,
					alpha: 0
				}, {
					duration: duration,
					easing: tween.cubicOut
				});
				tween(particle.scale, {
					x: 0.1,
					y: 0.1
				}, {
					duration: duration,
					easing: tween.linear
				});
			}
			// Remove explosion container after animation completes
			LK.setTimeout(function () {
				explosionEffect.destroy();
			}, 1000);
			// Apply power-up effect with enhanced visuals
			if (powerUp.getType() === 'gravity') {
				// Shake gravity field for dramatic effect
				var originalX = gravityField.x;
				var originalY = gravityField.y;
				var shakeCount = 0;
				var shakeInterval = LK.setInterval(function () {
					gravityField.x = originalX + (Math.random() * 20 - 10);
					gravityField.y = originalY + (Math.random() * 20 - 10);
					shakeCount++;
					if (shakeCount >= 10) {
						LK.clearInterval(shakeInterval);
						gravityField.x = originalX;
						gravityField.y = originalY;
						gravityField.reverseGravity();
					}
				}, 50);
			} else if (powerUp.getType() === 'multiball') {
				for (var j = 0; j < 2; j++) {
					var newBall = createBall();
					// Add a scale animation to new balls
					newBall.scale.set(0.2);
					tween(newBall.scale, {
						x: 1,
						y: 1
					}, {
						duration: 500,
						easing: tween.elasticOut
					});
				}
			}
			// Play sound and remove power-up
			LK.getSound('powerup').play();
			LK.effects.flashScreen(0x33FF57, 300);
			powerUp.destroy();
			powerUps.splice(i, 1);
		}
	}
}
// Handle AI movement
function updateAI() {
	// Find the closest ball
	var closestBall = null;
	var closestDistance = Infinity;
	for (var i = 0; i < balls.length; i++) {
		var ball = balls[i];
		if (ball.velocityY < 0) {
			// Ball is moving towards AI
			var distance = Math.abs(ball.x - aiPaddle.x);
			if (distance < closestDistance) {
				closestDistance = distance;
				closestBall = ball;
			}
		}
	}
	if (closestBall) {
		// Add some prediction based on velocity and gravity
		var predictedX = closestBall.x + closestBall.velocityX * (aiPaddle.y - closestBall.y) / Math.abs(closestBall.velocityY);
		aiPaddle.targetX = predictedX;
		// Add some difficulty scaling
		var difficultyFactor = 0.3 + gravityField.strength / gravityField.maxStrength * 0.6;
		aiPaddle.targetX = aiPaddle.x + (predictedX - aiPaddle.x) * difficultyFactor;
	}
}
// Event handler for touch/mouse down
game.down = function (x, y, obj) {
	// Only allow dragging the player paddle
	if (y > 2732 / 2) {
		dragTarget = playerPaddle;
		playerPaddle.targetX = x;
	}
};
// Event handler for touch/mouse move
game.move = function (x, y, obj) {
	if (dragTarget) {
		playerPaddle.targetX = x;
	}
};
// Event handler for touch/mouse up
game.up = function (x, y, obj) {
	dragTarget = null;
};
// Game update loop
game.update = function () {
	if (!gameActive) {
		return;
	}
	// Update AI
	updateAI();
	// Update paddles
	playerPaddle.update();
	aiPaddle.update();
	// Update balls
	for (var i = balls.length - 1; i >= 0; i--) {
		var ball = balls[i];
		// Apply gravity
		gravityField.applyGravityTo(ball);
		// Update ball position
		ball.update();
		// Check for paddle collisions
		var hitPlayer = checkPaddleCollision(ball, playerPaddle);
		var hitAI = checkPaddleCollision(ball, aiPaddle);
		// Check if ball is out of bounds (scoring)
		if (ball.y > 2732 + 50) {
			// AI scores
			aiPaddle.score++;
			// Animated score update
			animateScoreText(aiScoreText, aiPaddle.score.toString());
			LK.getSound('score').play();
			// Create a visual effect at ball position before destroying
			var scoreEffect = LK.getAsset('ball', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: ball.x,
				y: 2732,
				alpha: 0.8,
				scaleX: 1,
				scaleY: 1,
				tint: 0xff5733
			});
			game.addChild(scoreEffect);
			tween(scoreEffect.scale, {
				x: 3,
				y: 3
			}, {
				duration: 500,
				easing: tween.cubicOut,
				onFinish: function onFinish() {
					tween(scoreEffect, {
						alpha: 0
					}, {
						duration: 300,
						easing: tween.linear,
						onFinish: function onFinish() {
							scoreEffect.destroy();
						}
					});
				}
			});
			ball.destroy();
			balls.splice(i, 1);
			if (balls.length === 0) {
				createBall();
			}
			// Check for game over
			if (aiPaddle.score >= 10) {
				gameActive = false;
				LK.showGameOver();
			}
		} else if (ball.y < -50) {
			// Player scores
			playerPaddle.score++;
			// Animated score update
			animateScoreText(playerScoreText, playerPaddle.score.toString());
			LK.getSound('score').play();
			// Create a visual effect at ball position before destroying
			var scoreEffect = LK.getAsset('ball', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: ball.x,
				y: 0,
				alpha: 0.8,
				scaleX: 1,
				scaleY: 1,
				tint: 0x4287f5
			});
			game.addChild(scoreEffect);
			tween(scoreEffect.scale, {
				x: 3,
				y: 3
			}, {
				duration: 500,
				easing: tween.cubicOut,
				onFinish: function onFinish() {
					tween(scoreEffect, {
						alpha: 0
					}, {
						duration: 300,
						easing: tween.linear,
						onFinish: function onFinish() {
							scoreEffect.destroy();
						}
					});
				}
			});
			ball.destroy();
			balls.splice(i, 1);
			if (balls.length === 0) {
				createBall();
			}
			// Check for win
			if (playerPaddle.score >= 10) {
				gameActive = false;
				LK.showYouWin();
			}
		}
		// Check for power-up collisions
		checkPowerUpCollision(ball);
	}
};
// Initialize the game when code loads
initGame();

===================================================================
--- original.js
+++ change.js
@@ -10,10 +10,18 @@
 var Ball = Container.expand(function () {
 	var self = Container.call(this);
 	var ballGraphics = self.attachAsset('ball', {
 		anchorX: 0.5,
-		anchorY: 0.5
+		anchorY: 0.5,
+		alpha: 0.9
 	});
+	var glowBall = self.attachAsset('ball', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		alpha: 0.4,
+		scaleX: 1.5,
+		scaleY: 1.5
+	});
 	self.velocityX = 0;
 	self.velocityY = 0;
 	self.speed = 10;
 	self.gravityAffected = true;
@@ -21,9 +29,32 @@
 		self.x = 2048 / 2;
 		self.y = 2732 / 2;
 		self.velocityX = (Math.random() > 0.5 ? 1 : -1) * self.speed;
 		self.velocityY = (Math.random() * 2 - 1) * self.speed * 0.5;
+		// Add pulsating glow effect
+		self.startGlowAnimation();
 	};
+	self.startGlowAnimation = function () {
+		tween(glowBall.scale, {
+			x: 1.8,
+			y: 1.8
+		}, {
+			duration: 800,
+			easing: tween.sinceOut,
+			onFinish: function onFinish() {
+				tween(glowBall.scale, {
+					x: 1.5,
+					y: 1.5
+				}, {
+					duration: 800,
+					easing: tween.sinceIn,
+					onFinish: function onFinish() {
+						self.startGlowAnimation();
+					}
+				});
+			}
+		});
+	};
 	self.update = function () {
 		self.x += self.velocityX;
 		self.y += self.velocityY;
 		// Handle wall collisions
@@ -105,8 +136,17 @@
 	return self;
 });
 var Paddle = Container.expand(function () {
 	var self = Container.call(this);
+	// Create shadow effect
+	var paddleShadow = self.attachAsset('paddle', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		alpha: 0.3,
+		scaleX: 1.05,
+		scaleY: 1.8,
+		y: 8
+	});
 	var paddleGraphics = self.attachAsset('paddle', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
@@ -117,13 +157,24 @@
 	self.setup = function (isPlayer) {
 		self.isPlayer = isPlayer;
 		if (isPlayer) {
 			self.y = 2732 - 200;
+			paddleGraphics.tint = 0x4287f5; // Blue for player
 		} else {
 			self.y = 200;
+			paddleGraphics.tint = 0xff5733; // Orange for AI
 		}
 		self.x = 2048 / 2;
 		self.targetX = self.x;
+		// Create entrance animation
+		self.scale.set(0.1);
+		tween(self.scale, {
+			x: 1,
+			y: 1
+		}, {
+			duration: 800,
+			easing: tween.elasticOut
+		});
 	};
 	self.update = function () {
 		// Move toward target position with easing
 		if (Math.abs(self.x - self.targetX) > 1) {
@@ -191,14 +242,61 @@
 /**** 
 * Initialize Game
 ****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000022
+	backgroundColor: 0x000000
 });
 
 /**** 
 * Game Code
 ****/ 
+// Set a beautiful dark gradient background
+game.setBackgroundColor(0x0a0a2a);
+// Create a star field background
+function createStarfield() {
+	var starfield = new Container();
+	// Create stars with different sizes and opacities
+	for (var i = 0; i < 100; i++) {
+		var size = Math.random() * 4 + 1;
+		var star = LK.getAsset('ball', {
+			anchorX: 0.5,
+			anchorY: 0.5,
+			width: size,
+			height: size,
+			alpha: Math.random() * 0.7 + 0.3
+		});
+		star.x = Math.random() * 2048;
+		star.y = Math.random() * 2732;
+		// Create twinkling animation
+		var duration = Math.random() * 3000 + 2000;
+		// Create closure to keep reference to the current star
+		(function (starElement) {
+			function animateStar() {
+				tween(starElement, {
+					alpha: Math.random() * 0.5 + 0.1
+				}, {
+					duration: duration,
+					easing: tween.sinceInOut,
+					onFinish: function onFinish() {
+						tween(starElement, {
+							alpha: Math.random() * 0.7 + 0.3
+						}, {
+							duration: duration,
+							easing: tween.sinceInOut,
+							onFinish: animateStar
+						});
+					}
+				});
+			}
+			animateStar();
+		})(star);
+		starfield.addChild(star);
+	}
+	game.addChildAt(starfield, 0); // Add at the bottom layer
+	return starfield;
+}
+// Create starfield
+var starfield = createStarfield();
 // Create game elements
 var playerPaddle = new Paddle();
 var aiPaddle = new Paddle();
 var gravityField = new GravityField();
@@ -210,8 +308,28 @@
 var dragTarget = null;
 var difficultyTimer;
 var powerUpTimer;
 var gameActive = false;
+// Animate score text function
+function animateScoreText(textObject, newValue) {
+	// Store original scale
+	var originalScale = {
+		x: textObject.scale.x,
+		y: textObject.scale.y
+	};
+	// Set the new text
+	textObject.setText(newValue);
+	// Animate scale up and back down
+	tween.stop(textObject.scale);
+	textObject.scale.set(originalScale.x * 1.5, originalScale.y * 1.5);
+	tween(textObject.scale, {
+		x: originalScale.x,
+		y: originalScale.y
+	}, {
+		duration: 500,
+		easing: tween.elasticOut
+	});
+}
 // Initialize game state
 function initGame() {
 	// Setup players
 	playerPaddle.setup(true);
@@ -220,10 +338,11 @@
 	game.addChild(aiPaddle);
 	// Setup gravity field
 	gravityField.setup();
 	game.addChild(gravityField);
-	// Create center line
+	// Create center line with animation
 	centerLine = new Container();
+	centerLine.alpha = 0;
 	for (var i = 0; i < 20; i++) {
 		var dash = LK.getAsset('paddle', {
 			anchorX: 0.5,
 			anchorY: 0.5,
@@ -231,32 +350,91 @@
 			height: 10,
 			alpha: 0.5
 		});
 		dash.x = i * 110;
+		// Add staggered animation to each dash
+		(function (element, delay) {
+			element.alpha = 0;
+			element.scale.set(0.5);
+			LK.setTimeout(function () {
+				tween(element, {
+					alpha: 0.5
+				}, {
+					duration: 400,
+					easing: tween.linear
+				});
+				tween(element.scale, {
+					x: 1,
+					y: 1
+				}, {
+					duration: 600,
+					easing: tween.elasticOut
+				});
+			}, delay);
+		})(dash, i * 30);
 		centerLine.addChild(dash);
 	}
 	centerLine.x = 50;
 	centerLine.y = 2732 / 2;
 	game.addChild(centerLine);
-	// Create score text
+	tween(centerLine, {
+		alpha: 1
+	}, {
+		duration: 800,
+		easing: tween.linear
+	});
+	// Create score text with animated appearance
 	playerScoreText = new Text2('0', {
 		size: 150,
 		fill: 0xFFFFFF
 	});
 	playerScoreText.anchor.set(0.5, 1);
 	playerScoreText.x = 2048 / 2;
 	playerScoreText.y = 2732 - 50;
+	playerScoreText.alpha = 0;
+	playerScoreText.scale.set(0.5);
 	game.addChild(playerScoreText);
 	aiScoreText = new Text2('0', {
 		size: 150,
 		fill: 0xFFFFFF
 	});
 	aiScoreText.anchor.set(0.5, 0);
 	aiScoreText.x = 2048 / 2;
 	aiScoreText.y = 50;
+	aiScoreText.alpha = 0;
+	aiScoreText.scale.set(0.5);
 	game.addChild(aiScoreText);
-	// Create first ball
-	createBall();
+	// Animate score text appearance
+	tween(playerScoreText, {
+		alpha: 1
+	}, {
+		duration: 800,
+		easing: tween.linear
+	});
+	tween(playerScoreText.scale, {
+		x: 1,
+		y: 1
+	}, {
+		duration: 1000,
+		easing: tween.elasticOut
+	});
+	tween(aiScoreText, {
+		alpha: 1
+	}, {
+		duration: 800,
+		easing: tween.linear
+	});
+	tween(aiScoreText.scale, {
+		x: 1,
+		y: 1
+	}, {
+		duration: 1000,
+		easing: tween.elasticOut
+	});
+	// Create first ball with delay to allow UI elements to animate in
+	LK.setTimeout(function () {
+		createBall();
+	}, 1200);
 	// Setup difficulty increases
 	difficultyTimer = LK.setInterval(function () {
 		if (gameActive) {
 			gravityField.increaseStrength();
@@ -302,10 +480,20 @@
 			// Increase speed slightly
 			ball.speed = Math.min(20, ball.speed * 1.05);
 			// Play bounce sound
 			LK.getSound('bounce').play();
-			// Flash paddle
-			LK.effects.flashObject(paddle, 0xFFFFFF, 300);
+			// Enhanced paddle hit effect - scale and flash
+			tween.stop(paddle.scale);
+			paddle.scale.set(1.2, 0.8);
+			tween(paddle.scale, {
+				x: 1,
+				y: 1
+			}, {
+				duration: 300,
+				easing: tween.elasticOut
+			});
+			// Flash paddle with color based on player
+			LK.effects.flashObject(paddle, paddle.isPlayer ? 0x4287f5 : 0xff5733, 300);
 			return true;
 		}
 	}
 	return false;
@@ -314,14 +502,78 @@
 function checkPowerUpCollision(ball) {
 	for (var i = powerUps.length - 1; i >= 0; i--) {
 		var powerUp = powerUps[i];
 		if (ball.intersects(powerUp)) {
-			// Apply power-up effect
+			// Create explosion effect at power-up location
+			var explosionEffect = new Container();
+			explosionEffect.x = powerUp.x;
+			explosionEffect.y = powerUp.y;
+			game.addChild(explosionEffect);
+			// Create multiple particles for explosion
+			for (var p = 0; p < 10; p++) {
+				var particle = LK.getAsset(powerUp.getType() === 'gravity' ? 'powerUpGravity' : 'powerUpMultiBall', {
+					anchorX: 0.5,
+					anchorY: 0.5,
+					scale: 0.5,
+					alpha: 0.8
+				});
+				// Randomize particle position and movement
+				var angle = Math.random() * Math.PI * 2;
+				var distance = Math.random() * 100 + 50;
+				var duration = Math.random() * 500 + 500;
+				particle.x = 0;
+				particle.y = 0;
+				explosionEffect.addChild(particle);
+				// Animate particle movement and fade
+				tween(particle, {
+					x: Math.cos(angle) * distance,
+					y: Math.sin(angle) * distance,
+					alpha: 0
+				}, {
+					duration: duration,
+					easing: tween.cubicOut
+				});
+				tween(particle.scale, {
+					x: 0.1,
+					y: 0.1
+				}, {
+					duration: duration,
+					easing: tween.linear
+				});
+			}
+			// Remove explosion container after animation completes
+			LK.setTimeout(function () {
+				explosionEffect.destroy();
+			}, 1000);
+			// Apply power-up effect with enhanced visuals
 			if (powerUp.getType() === 'gravity') {
-				gravityField.reverseGravity();
+				// Shake gravity field for dramatic effect
+				var originalX = gravityField.x;
+				var originalY = gravityField.y;
+				var shakeCount = 0;
+				var shakeInterval = LK.setInterval(function () {
+					gravityField.x = originalX + (Math.random() * 20 - 10);
+					gravityField.y = originalY + (Math.random() * 20 - 10);
+					shakeCount++;
+					if (shakeCount >= 10) {
+						LK.clearInterval(shakeInterval);
+						gravityField.x = originalX;
+						gravityField.y = originalY;
+						gravityField.reverseGravity();
+					}
+				}, 50);
 			} else if (powerUp.getType() === 'multiball') {
 				for (var j = 0; j < 2; j++) {
-					createBall();
+					var newBall = createBall();
+					// Add a scale animation to new balls
+					newBall.scale.set(0.2);
+					tween(newBall.scale, {
+						x: 1,
+						y: 1
+					}, {
+						duration: 500,
+						easing: tween.elasticOut
+					});
 				}
 			}
 			// Play sound and remove power-up
 			LK.getSound('powerup').play();
@@ -397,10 +649,41 @@
 		// Check if ball is out of bounds (scoring)
 		if (ball.y > 2732 + 50) {
 			// AI scores
 			aiPaddle.score++;
-			aiScoreText.setText(aiPaddle.score.toString());
+			// Animated score update
+			animateScoreText(aiScoreText, aiPaddle.score.toString());
 			LK.getSound('score').play();
+			// Create a visual effect at ball position before destroying
+			var scoreEffect = LK.getAsset('ball', {
+				anchorX: 0.5,
+				anchorY: 0.5,
+				x: ball.x,
+				y: 2732,
+				alpha: 0.8,
+				scaleX: 1,
+				scaleY: 1,
+				tint: 0xff5733
+			});
+			game.addChild(scoreEffect);
+			tween(scoreEffect.scale, {
+				x: 3,
+				y: 3
+			}, {
+				duration: 500,
+				easing: tween.cubicOut,
+				onFinish: function onFinish() {
+					tween(scoreEffect, {
+						alpha: 0
+					}, {
+						duration: 300,
+						easing: tween.linear,
+						onFinish: function onFinish() {
+							scoreEffect.destroy();
+						}
+					});
+				}
+			});
 			ball.destroy();
 			balls.splice(i, 1);
 			if (balls.length === 0) {
 				createBall();
@@ -412,10 +695,41 @@
 			}
 		} else if (ball.y < -50) {
 			// Player scores
 			playerPaddle.score++;
-			playerScoreText.setText(playerPaddle.score.toString());
+			// Animated score update
+			animateScoreText(playerScoreText, playerPaddle.score.toString());
 			LK.getSound('score').play();
+			// Create a visual effect at ball position before destroying
+			var scoreEffect = LK.getAsset('ball', {
+				anchorX: 0.5,
+				anchorY: 0.5,
+				x: ball.x,
+				y: 0,
+				alpha: 0.8,
+				scaleX: 1,
+				scaleY: 1,
+				tint: 0x4287f5
+			});
+			game.addChild(scoreEffect);
+			tween(scoreEffect.scale, {
+				x: 3,
+				y: 3
+			}, {
+				duration: 500,
+				easing: tween.cubicOut,
+				onFinish: function onFinish() {
+					tween(scoreEffect, {
+						alpha: 0
+					}, {
+						duration: 300,
+						easing: tween.linear,
+						onFinish: function onFinish() {
+							scoreEffect.destroy();
+						}
+					});
+				}
+			});
 			ball.destroy();
 			balls.splice(i, 1);
 			if (balls.length === 0) {
 				createBall();