===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,434 @@
-/****
+/**** 
+* 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
+	});
+	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;
+	};
+	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);
+	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;
+		} else {
+			self.y = 200;
+		}
+		self.x = 2048 / 2;
+		self.targetX = self.x;
+	};
+	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
-});
\ No newline at end of file
+	backgroundColor: 0x000022
+});
+
+/**** 
+* Game Code
+****/ 
+// 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;
+// 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
+	centerLine = new Container();
+	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;
+		centerLine.addChild(dash);
+	}
+	centerLine.x = 50;
+	centerLine.y = 2732 / 2;
+	game.addChild(centerLine);
+	// Create score text
+	playerScoreText = new Text2('0', {
+		size: 150,
+		fill: 0xFFFFFF
+	});
+	playerScoreText.anchor.set(0.5, 1);
+	playerScoreText.x = 2048 / 2;
+	playerScoreText.y = 2732 - 50;
+	game.addChild(playerScoreText);
+	aiScoreText = new Text2('0', {
+		size: 150,
+		fill: 0xFFFFFF
+	});
+	aiScoreText.anchor.set(0.5, 0);
+	aiScoreText.x = 2048 / 2;
+	aiScoreText.y = 50;
+	game.addChild(aiScoreText);
+	// Create first ball
+	createBall();
+	// 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();
+			// Flash paddle
+			LK.effects.flashObject(paddle, 0xFFFFFF, 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)) {
+			// Apply power-up effect
+			if (powerUp.getType() === 'gravity') {
+				gravityField.reverseGravity();
+			} else if (powerUp.getType() === 'multiball') {
+				for (var j = 0; j < 2; j++) {
+					createBall();
+				}
+			}
+			// 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++;
+			aiScoreText.setText(aiPaddle.score.toString());
+			LK.getSound('score').play();
+			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++;
+			playerScoreText.setText(playerPaddle.score.toString());
+			LK.getSound('score').play();
+			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();
\ No newline at end of file