===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,498 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1", {
+	highScore: 0,
+	difficulty: 1,
+	gameMode: "single"
+});
+
+/**** 
+* Classes
+****/ 
+var Ball = Container.expand(function () {
+	var self = Container.call(this);
+	self.graphics = self.attachAsset('ball', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.radius = 15; // Half of the ball width/height
+	self.speedX = 0;
+	self.speedY = 0;
+	self.baseSpeed = 12;
+	self.reset = function () {
+		self.x = 2048 / 2;
+		self.y = 2732 / 2;
+		// Randomize initial direction
+		var angle = Math.random() * Math.PI / 4 + Math.PI / 4; // 45-90 degrees
+		if (Math.random() < 0.5) {
+			angle = Math.PI - angle;
+		} // Left or right
+		self.speedX = Math.cos(angle) * self.baseSpeed;
+		self.speedY = (Math.random() < 0.5 ? -1 : 1) * Math.sin(angle) * self.baseSpeed;
+	};
+	self.increaseSpeed = function () {
+		var currentSpeed = Math.sqrt(self.speedX * self.speedX + self.speedY * self.speedY);
+		var multiplier = 1.2;
+		self.speedX = self.speedX / currentSpeed * (currentSpeed * multiplier);
+		self.speedY = self.speedY / currentSpeed * (currentSpeed * multiplier);
+	};
+	self.update = function () {
+		// Update position
+		self.x += self.speedX;
+		self.y += self.speedY;
+		// Handle collisions with side walls
+		if (self.x - self.radius < 0) {
+			self.x = self.radius;
+			self.speedX = -self.speedX;
+			LK.getSound('hit').play();
+		} else if (self.x + self.radius > 2048) {
+			self.x = 2048 - self.radius;
+			self.speedX = -self.speedX;
+			LK.getSound('hit').play();
+		}
+		// Check for collisions with paddles
+		self.checkPaddleCollisions();
+		// Check for score (ball off screen)
+		if (self.y - self.radius < 0) {
+			// Opponent scores
+			increaseScore(false);
+			self.reset();
+		} else if (self.y + self.radius > 2732) {
+			// Player scores
+			increaseScore(true);
+			self.reset();
+		}
+	};
+	self.checkPaddleCollisions = function () {
+		// Check collision with player paddle
+		if (self.speedY > 0 && self.y + self.radius >= playerPaddle.y - playerPaddle.height / 2 && self.y - self.radius <= playerPaddle.y + playerPaddle.height / 2 && self.x >= playerPaddle.x - playerPaddle.graphics.width / 2 && self.x <= playerPaddle.x + playerPaddle.graphics.width / 2) {
+			// Bounce with angle based on hit position
+			self.speedY = -self.speedY;
+			var hitPos = (self.x - playerPaddle.x) / (playerPaddle.graphics.width / 2);
+			self.speedX = hitPos * (self.baseSpeed * 0.8);
+			// Ensure minimum vertical speed
+			var currentSpeed = Math.sqrt(self.speedX * self.speedX + self.speedY * self.speedY);
+			if (currentSpeed < self.baseSpeed) {
+				var factor = self.baseSpeed / currentSpeed;
+				self.speedX *= factor;
+				self.speedY *= factor;
+			}
+			self.y = playerPaddle.y - playerPaddle.height / 2 - self.radius - 1; // Move out of collision
+			LK.getSound('hit').play();
+		}
+		// Check collision with opponent paddle
+		if (self.speedY < 0 && self.y - self.radius <= opponentPaddle.y + opponentPaddle.height / 2 && self.y + self.radius >= opponentPaddle.y - opponentPaddle.height / 2 && self.x >= opponentPaddle.x - opponentPaddle.graphics.width / 2 && self.x <= opponentPaddle.x + opponentPaddle.graphics.width / 2) {
+			// Bounce with angle based on hit position
+			self.speedY = -self.speedY;
+			var hitPos = (self.x - opponentPaddle.x) / (opponentPaddle.graphics.width / 2);
+			self.speedX = hitPos * (self.baseSpeed * 0.8);
+			// Ensure minimum vertical speed
+			var currentSpeed = Math.sqrt(self.speedX * self.speedX + self.speedY * self.speedY);
+			if (currentSpeed < self.baseSpeed) {
+				var factor = self.baseSpeed / currentSpeed;
+				self.speedX *= factor;
+				self.speedY *= factor;
+			}
+			self.y = opponentPaddle.y + opponentPaddle.height / 2 + self.radius + 1; // Move out of collision
+			LK.getSound('hit').play();
+		}
+	};
+	return self;
+});
+var Paddle = Container.expand(function () {
+	var self = Container.call(this);
+	self.width = 300;
+	self.height = 50;
+	self.speed = 15;
+	self.originalWidth = 300;
+	self.init = function (isPlayer) {
+		self.isPlayer = isPlayer;
+		var assetId = isPlayer ? 'paddlePlayer' : 'paddleOpponent';
+		self.graphics = self.attachAsset(assetId, {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+	};
+	self.resetSize = function () {
+		tween(self.graphics, {
+			width: self.originalWidth
+		}, {
+			duration: 300,
+			easing: tween.easeOut
+		});
+	};
+	self.enlarge = function () {
+		tween(self.graphics, {
+			width: self.originalWidth * 1.5
+		}, {
+			duration: 300,
+			easing: tween.easeOut
+		});
+	};
+	self.shrink = function () {
+		tween(self.graphics, {
+			width: self.originalWidth * 0.7
+		}, {
+			duration: 300,
+			easing: tween.easeOut
+		});
+	};
+	self.update = function () {
+		// AI movement for opponent in single player mode
+		if (!self.isPlayer && gameMode === 'single' && ball) {
+			var targetX = ball.x;
+			var difficulty = storage.difficulty || 1; // 1-3 (easy to hard)
+			var maxSpeed = self.speed * (0.5 + difficulty * 0.25);
+			// Add some delay and imperfection for easier difficulties
+			if (difficulty < 3) {
+				var reactionDelay = (3 - difficulty) * 10;
+				if (LK.ticks % reactionDelay === 0) {
+					// Only update target position occasionally based on difficulty
+					var error = (3 - difficulty) * 100;
+					targetX += Math.random() * error * 2 - error;
+				}
+			}
+			// Move paddle towards the ball with speed based on difficulty
+			var moveDirection = targetX > self.x ? 1 : -1;
+			var distance = Math.abs(targetX - self.x);
+			if (distance > 10) {
+				var moveAmount = Math.min(distance, maxSpeed);
+				self.x += moveDirection * moveAmount;
+			}
+		}
+		// Keep paddles within game boundaries
+		if (self.x < self.graphics.width / 2) {
+			self.x = self.graphics.width / 2;
+		} else if (self.x > 2048 - self.graphics.width / 2) {
+			self.x = 2048 - self.graphics.width / 2;
+		}
+	};
+	return self;
+});
+var PowerUp = Container.expand(function () {
+	var self = Container.call(this);
+	self.graphics = self.attachAsset('powerUp', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.type = 'none';
+	self.active = false;
+	self.radius = 25; // Half of the powerup width/height
+	self.spawn = function () {
+		// Choose random type
+		var types = ['speed', 'enlarge', 'shrink'];
+		self.type = types[Math.floor(Math.random() * types.length)];
+		// Set position randomly on field
+		self.x = Math.random() * (2048 - 200) + 100;
+		self.y = Math.random() * (2732 - 500) + 250;
+		// Set color based on type
+		switch (self.type) {
+			case 'speed':
+				self.graphics.tint = 0xff5500; // Orange
+				break;
+			case 'enlarge':
+				self.graphics.tint = 0x00ff00; // Green
+				break;
+			case 'shrink':
+				self.graphics.tint = 0xff0000; // Red
+				break;
+		}
+		self.active = true;
+		game.addChild(self);
+		// Auto-despawn after 7 seconds
+		LK.setTimeout(function () {
+			if (self.active) {
+				self.despawn();
+			}
+		}, 7000);
+	};
+	self.despawn = function () {
+		self.active = false;
+		game.removeChild(self);
+	};
+	self.update = function () {
+		if (!self.active || !ball) {
+			return;
+		}
+		// Check collision with ball
+		var dx = ball.x - self.x;
+		var dy = ball.y - self.y;
+		var distance = Math.sqrt(dx * dx + dy * dy);
+		if (distance < ball.radius + self.radius) {
+			self.applyEffect();
+			self.despawn();
+			LK.getSound('powerup').play();
+		}
+	};
+	self.applyEffect = function () {
+		switch (self.type) {
+			case 'speed':
+				ball.increaseSpeed();
+				LK.effects.flashObject(ball, 0xff5500, 1000); // Flash orange
+				break;
+			case 'enlarge':
+				// Enlarge the paddle that's about to receive the ball
+				if (ball.speedY > 0) {
+					playerPaddle.enlarge();
+					LK.effects.flashObject(playerPaddle, 0x00ff00, 1000); // Flash green
+					// Reset size after 10 seconds
+					LK.setTimeout(function () {
+						playerPaddle.resetSize();
+					}, 10000);
+				} else {
+					opponentPaddle.enlarge();
+					LK.effects.flashObject(opponentPaddle, 0x00ff00, 1000); // Flash green
+					// Reset size after 10 seconds
+					LK.setTimeout(function () {
+						opponentPaddle.resetSize();
+					}, 10000);
+				}
+				break;
+			case 'shrink':
+				// Shrink the paddle that's about to receive the ball
+				if (ball.speedY > 0) {
+					opponentPaddle.shrink();
+					LK.effects.flashObject(opponentPaddle, 0xff0000, 1000); // Flash red
+					// Reset size after 10 seconds
+					LK.setTimeout(function () {
+						opponentPaddle.resetSize();
+					}, 10000);
+				} else {
+					playerPaddle.shrink();
+					LK.effects.flashObject(playerPaddle, 0xff0000, 1000); // Flash red
+					// Reset size after 10 seconds
+					LK.setTimeout(function () {
+						playerPaddle.resetSize();
+					}, 10000);
+				}
+				break;
+		}
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
+	backgroundColor: 0x222222
+});
+
+/**** 
+* Game Code
+****/ 
+// Game variables
+var gameMode = storage.gameMode || 'single';
+var playerScore = 0;
+var opponentScore = 0;
+var maxScore = 5;
+var isPaused = false;
+var activePowerUp = null;
+var draggingPlayerPaddle = false;
+var draggingOpponentPaddle = false;
+// Game elements
+var playerPaddle;
+var opponentPaddle;
+var ball;
+var centerLine;
+// UI elements
+var playerScoreText;
+var opponentScoreText;
+var gameModeText;
+var gameModeToggle;
+function setupGameElements() {
+	// Create center line
+	centerLine = LK.getAsset('centerLine', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		alpha: 0.3
+	});
+	centerLine.x = 2048 / 2;
+	centerLine.y = 2732 / 2;
+	game.addChild(centerLine);
+	// Create paddles
+	playerPaddle = new Paddle();
+	playerPaddle.init(true);
+	playerPaddle.x = 2048 / 2;
+	playerPaddle.y = 2732 - 200;
+	game.addChild(playerPaddle);
+	opponentPaddle = new Paddle();
+	opponentPaddle.init(false);
+	opponentPaddle.x = 2048 / 2;
+	opponentPaddle.y = 200;
+	game.addChild(opponentPaddle);
+	// Create ball
+	ball = new Ball();
+	ball.reset();
+	game.addChild(ball);
+	// Create power-up
+	activePowerUp = new PowerUp();
+	// Schedule regular power-up spawns
+	LK.setInterval(function () {
+		if (!activePowerUp.active) {
+			activePowerUp.spawn();
+		}
+	}, 15000); // Every 15 seconds
+	// Set up UI
+	setupUI();
+}
+function setupUI() {
+	// Player score text
+	playerScoreText = new Text2('0', {
+		size: 120,
+		fill: 0x3498DB
+	});
+	playerScoreText.anchor.set(0.5, 0.5);
+	playerScoreText.x = 2048 / 2;
+	playerScoreText.y = 2732 / 2 + 150;
+	game.addChild(playerScoreText);
+	// Opponent score text
+	opponentScoreText = new Text2('0', {
+		size: 120,
+		fill: 0xE74C3C
+	});
+	opponentScoreText.anchor.set(0.5, 0.5);
+	opponentScoreText.x = 2048 / 2;
+	opponentScoreText.y = 2732 / 2 - 150;
+	game.addChild(opponentScoreText);
+	// Game mode text
+	gameModeText = new Text2(gameMode === 'single' ? 'SINGLE PLAYER' : 'MULTIPLAYER', {
+		size: 40,
+		fill: 0xFFFFFF
+	});
+	gameModeText.anchor.set(0.5, 0.5);
+	LK.gui.topRight.addChild(gameModeText);
+	gameModeText.x = -200;
+	gameModeText.y = 100;
+	// Game mode toggle button
+	gameModeToggle = LK.getAsset('centerLine', {
+		width: 300,
+		height: 60,
+		color: 0x555555,
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	gameModeToggle.x = -200;
+	gameModeToggle.y = 180;
+	var toggleText = new Text2('CHANGE MODE', {
+		size: 30,
+		fill: 0xFFFFFF
+	});
+	toggleText.anchor.set(0.5, 0.5);
+	gameModeToggle.addChild(toggleText);
+	LK.gui.topRight.addChild(gameModeToggle);
+	// Add event listener for mode toggle
+	gameModeToggle.interactive = true;
+	gameModeToggle.down = function () {
+		toggleGameMode();
+	};
+}
+function toggleGameMode() {
+	gameMode = gameMode === 'single' ? 'multi' : 'single';
+	storage.gameMode = gameMode;
+	gameModeText.setText(gameMode === 'single' ? 'SINGLE PLAYER' : 'MULTIPLAYER');
+	// Reset game when mode changes
+	resetGame();
+}
+function resetGame() {
+	playerScore = 0;
+	opponentScore = 0;
+	updateScoreDisplay();
+	if (ball) {
+		ball.reset();
+	}
+	if (playerPaddle) {
+		playerPaddle.x = 2048 / 2;
+		playerPaddle.resetSize();
+	}
+	if (opponentPaddle) {
+		opponentPaddle.x = 2048 / 2;
+		opponentPaddle.resetSize();
+	}
+	if (activePowerUp && activePowerUp.active) {
+		activePowerUp.despawn();
+	}
+}
+function increaseScore(isPlayer) {
+	if (isPlayer) {
+		playerScore++;
+	} else {
+		opponentScore++;
+	}
+	updateScoreDisplay();
+	LK.getSound('score').play();
+	// Check for game over
+	if (playerScore >= maxScore || opponentScore >= maxScore) {
+		LK.setTimeout(function () {
+			if (playerScore >= maxScore) {
+				LK.showYouWin();
+			} else {
+				LK.showGameOver();
+			}
+		}, 500);
+	}
+}
+function updateScoreDisplay() {
+	playerScoreText.setText(playerScore.toString());
+	opponentScoreText.setText(opponentScore.toString());
+}
+function handlePaddleMovement(x, y) {
+	if (draggingPlayerPaddle) {
+		playerPaddle.x = x;
+	}
+	if (gameMode === 'multi' && draggingOpponentPaddle) {
+		opponentPaddle.x = x;
+	}
+}
+// Input handlers
+game.down = function (x, y, obj) {
+	// Check if clicking on player paddle
+	if (y > 2732 / 2) {
+		draggingPlayerPaddle = true;
+		handlePaddleMovement(x, y);
+	}
+	// Check if clicking on opponent paddle (only in multiplayer)
+	else if (gameMode === 'multi' && y < 2732 / 2) {
+		draggingOpponentPaddle = true;
+		handlePaddleMovement(x, y);
+	}
+};
+game.up = function (x, y, obj) {
+	draggingPlayerPaddle = false;
+	draggingOpponentPaddle = false;
+};
+game.move = function (x, y, obj) {
+	handlePaddleMovement(x, y);
+};
+// Game loop
+game.update = function () {
+	if (isPaused) {
+		return;
+	}
+	// Update game elements
+	if (playerPaddle) {
+		playerPaddle.update();
+	}
+	if (opponentPaddle) {
+		opponentPaddle.update();
+	}
+	if (ball) {
+		ball.update();
+	}
+	if (activePowerUp && activePowerUp.active) {
+		activePowerUp.update();
+	}
+};
+// Initialize game
+setupGameElements();
+resetGame();
+// Play background music
+LK.playMusic('gameMusic', {
+	fade: {
+		start: 0,
+		end: 0.3,
+		duration: 1000
+	}
 });
\ No newline at end of file