/**** 
* Classes
****/
// Ball class
var Ball = Container.expand(function () {
	var self = Container.call(this);
	var ballGraphics = self.createAsset('ball', 'Ball asset', 0.5, 0.5);
	self.mass = 10;
	self.velocity = {
		x: 0,
		y: 0
	};
	self.radius = ballGraphics.width / 2;
	self.update = function () {
		self.x += self.velocity.x;
		self.y += self.velocity.y;
	};
	self.reset = function () {
		var safeZone = planet.radius * 3;
		var minX = safeZone;
		var maxX = game.width - safeZone;
		var minY = safeZone;
		var maxY = game.height - safeZone;
		do {
			self.x = Math.random() * (maxX - minX) + minX;
			self.y = Math.random() * (maxY - minY) + minY;
			var dx = planet.x - self.x;
			var dy = planet.y - self.y;
		} while (Math.sqrt(dx * dx + dy * dy) < safeZone);
		var angle = Math.random() * Math.PI * 2;
		self.velocity = {
			x: Math.cos(angle) * 15,
			// Increased initial speed
			y: Math.sin(angle) * 15 // Increased initial speed
		};
	};
});
// Paddle class
var Paddle = Container.expand(function () {
	var self = Container.call(this);
	var paddleGraphics = self.createAsset('paddle', 'Paddle asset', 0.5, 0.5);
	self.update = function () {
		// Paddle update logic
	};
});
// Planet class
var Planet = Container.expand(function () {
	var self = Container.call(this);
	var planetGraphics = self.createAsset('planet', 'Planet asset', 0.5, 0.5);
	self.mass = 5000; // Reduced mass for gravity calculation
	self.radius = planetGraphics.width / 2;
	self.x = game.width / 2 + 100;
	self.y = game.height / 2 + 500;
});
// SecondPlanet class
var SecondPlanet = Container.expand(function () {
	var self = Container.call(this);
	var planetGraphics = self.createAsset('secondPlanet', 'Second Planet asset', 0.5, 0.5);
	self.mass = 2500; // Reduced mass for weaker gravity calculation
	self.radius = planetGraphics.width / 2;
	self.x = game.width / 2 - 100;
	self.y = game.height / 2 - 550; // Position the second planet above the first
});
// Satellite class
var Satellite = Container.expand(function () {
	var self = Container.call(this);
	var satelliteGraphics = self.createAsset('satellite', 'Satellite asset', 0.5, 0.5);
	self.orbitRadius = 0;
	self.orbitSpeed = 0.01;
	self.orbitAngle = Math.random() * Math.PI * 2;
	self.update = function (planets) {
		self.orbitAngle += self.orbitSpeed;
		var dx = planet.x - game.width / 2;
		var dy = planet.y - game.height / 2;
		var ellipseRatio = 3;
		// Reduce the mass of the satellite to decrease gravitational force
		self.mass = 1000; // Adjusted mass for weaker gravity calculation
		self.x = game.width / 2 + self.orbitRadius * ellipseRatio * Math.cos(self.orbitAngle) + dx + 1500;
		self.y = game.height / 2 + self.orbitRadius / ellipseRatio * Math.sin(self.orbitAngle) + dy;
		if (self.x < -self.width * 2 || self.x > game.width + self.width * 2 || self.y < -self.height * 2 || self.y > game.height + self.height * 2) {
			self.orbitRadius = Math.max(game.width, game.height) / 3.5;
		}
	};
	self.reset = function () {
		self.orbitRadius = Math.max(game.width, game.height) / 4;
		self.orbitSpeed = Math.random() * 0.02 + 0.005;
		self.orbitAngle = Math.random() * Math.PI * 2;
	};
});
// EllipticalOrbitObject class
var EllipticalOrbitObject = Container.expand(function () {
	var self = Container.call(this);
	var orbitObjectGraphics = self.createAsset('ellipticalOrbitObject', 'Elliptical Orbit Object asset', 0.5, 0.5);
	self.orbitRadius = 0;
	self.orbitSpeed = 0.01;
	self.orbitAngle = Math.random() * Math.PI * 2;
	self.update = function (secondPlanet) {
		self.orbitAngle += self.orbitSpeed;
		var dx = secondPlanet.x - self.x;
		var dy = secondPlanet.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		var gravity = secondPlanet.mass / (distance * distance);
		var gravityX = dx / distance * gravity;
		var gravityY = dy / distance * gravity;
		self.velocity.x = (self.velocity.x || 0) + gravityX;
		self.velocity.y = (self.velocity.y || 0) + gravityY;
		var ellipseRatio = 2; // Ratio for the elliptical orbit
		self.x += self.velocity.x;
		self.y += self.velocity.y;
		if (self.x < -self.width * 2 || self.x > game.width + self.width * 2 || self.y < -self.height * 2 || self.y > game.height + self.height * 2) {
			self.orbitRadius = Math.max(game.width, game.height) / 4;
			self.velocity.x = 0;
			self.velocity.y = 0;
		}
	};
	self.reset = function () {
		self.orbitRadius = Math.max(game.width, game.height) / 5;
		self.orbitSpeed = Math.random() * 0.02 + 0.005;
		self.orbitAngle = Math.random() * Math.PI * 2;
	};
});
// Background class
var Background = Container.expand(function () {
	var self = Container.call(this);
	var backgroundGraphics = self.createAsset('background', 'Background asset', 0, 0);
	backgroundGraphics.width = game.width;
	backgroundGraphics.height = game.height;
	self.addChild(backgroundGraphics);
});

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

/**** 
* Game Code
****/
// Initialize background
var background = game.addChild(new Background());
// Initialize game elements
var ball = game.addChild(new Ball());
var leftPaddle = game.addChild(new Paddle());
var rightPaddle = game.addChild(new Paddle());
var planet = game.addChild(new Planet());
// Set initial positions
leftPaddle.x = 100;
leftPaddle.y = game.height / 2;
rightPaddle.x = game.width - 100;
rightPaddle.y = game.height / 2;
var secondPlanet = game.addChild(new SecondPlanet());
ball.reset();
// Initialize the elliptical orbit object
var ellipticalOrbitObject = game.addChild(new EllipticalOrbitObject());
ellipticalOrbitObject.reset();
// Initialize satellite
var satellite = game.addChild(new Satellite());
satellite.reset();
// Game logic
LK.on('tick', function () {
	ball.update();
	leftPaddle.update();
	rightPaddle.update();
	// Check for collisions with paddles and prevent ball from passing through
	if (ball.intersects(leftPaddle)) {
		ball.velocity.x = Math.abs(ball.velocity.x);
		ball.x = leftPaddle.x + leftPaddle.width / 2 + ball.radius;
	} else if (ball.intersects(rightPaddle)) {
		ball.velocity.x = -Math.abs(ball.velocity.x);
		ball.x = rightPaddle.x - rightPaddle.width / 2 - ball.radius;
	}
	// Check for collisions with top and bottom boundaries
	if (ball.y - ball.radius <= 0 || ball.y + ball.radius >= game.height) {
		ball.velocity.y *= -1;
	}
	// Gravity effect from planets
	var planets = [planet, secondPlanet];
	planets.forEach(function (currentPlanet) {
		var dx = currentPlanet.x - ball.x;
		var dy = currentPlanet.y - ball.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		var safeDistance = (currentPlanet.radius + ball.radius + 50) * 2; // Doubling the safe margin to increase gravity range
		if (distance < safeDistance) {
			// Adjusted gravity effect to maintain a safe distance
			var gravity = currentPlanet.mass / (distance * distance) * (7 * (currentPlanet === secondPlanet ? 1.8 * 1.3 : 1.3)); // Adjust gravity based on planet
			var gravityX = dx / distance * gravity;
			var gravityY = dy / distance * gravity;
			ball.velocity.x += gravityX * (1 - (safeDistance - distance) / safeDistance);
			ball.velocity.y += gravityY * (1 - (safeDistance - distance) / safeDistance);
		}
	});
	// Update satellite orbit and check for collision with the ball
	satellite.update(planets);
	if (satellite.intersects(ball)) {
		// Reflect ball velocity
		var normalX = ball.x - satellite.x;
		var normalY = ball.y - satellite.y;
		var normalLength = Math.sqrt(normalX * normalX + normalY * normalY);
		normalX /= normalLength;
		normalY /= normalLength;
		var dotProduct = ball.velocity.x * normalX + ball.velocity.y * normalY;
		ball.velocity.x -= 2 * dotProduct * normalX;
		ball.velocity.y -= 2 * dotProduct * normalY;
	}
	// Reset ball if it goes off screen
	if (ball.x < -ball.radius || ball.x > game.width + ball.radius) {
		ball.reset();
	}
	// Update the elliptical orbit object
	ellipticalOrbitObject.update(secondPlanet);
});
// Touch controls for paddles
function handleTouch(obj) {
	var touchPos = obj.event.getLocalPosition(game);
	if (touchPos.x < game.width / 2) {
		leftPaddle.y = touchPos.y;
	} else {
		rightPaddle.y = touchPos.y;
	}
}
game.on('down', handleTouch);
game.on('move', handleTouch);

===================================================================
--- original.js
+++ change.js
@@ -95,15 +95,23 @@
 	self.orbitSpeed = 0.01;
 	self.orbitAngle = Math.random() * Math.PI * 2;
 	self.update = function (secondPlanet) {
 		self.orbitAngle += self.orbitSpeed;
-		var dx = secondPlanet.x - game.width / 2;
-		var dy = secondPlanet.y - game.height / 2;
+		var dx = secondPlanet.x - self.x;
+		var dy = secondPlanet.y - self.y;
+		var distance = Math.sqrt(dx * dx + dy * dy);
+		var gravity = secondPlanet.mass / (distance * distance);
+		var gravityX = dx / distance * gravity;
+		var gravityY = dy / distance * gravity;
+		self.velocity.x = (self.velocity.x || 0) + gravityX;
+		self.velocity.y = (self.velocity.y || 0) + gravityY;
 		var ellipseRatio = 2; // Ratio for the elliptical orbit
-		self.x = game.width / 2 + self.orbitRadius / ellipseRatio * Math.sin(self.orbitAngle + Math.PI / 2) + dx;
-		self.y = game.height / 2 + self.orbitRadius * ellipseRatio * Math.cos(self.orbitAngle + Math.PI / 2) + dy - 900;
+		self.x += self.velocity.x;
+		self.y += self.velocity.y;
 		if (self.x < -self.width * 2 || self.x > game.width + self.width * 2 || self.y < -self.height * 2 || self.y > game.height + self.height * 2) {
 			self.orbitRadius = Math.max(game.width, game.height) / 4;
+			self.velocity.x = 0;
+			self.velocity.y = 0;
 		}
 	};
 	self.reset = function () {
 		self.orbitRadius = Math.max(game.width, game.height) / 5;
@@ -200,35 +208,10 @@
 	// Reset ball if it goes off screen
 	if (ball.x < -ball.radius || ball.x > game.width + ball.radius) {
 		ball.reset();
 	}
-	// Update the elliptical orbit object, apply gravity, and check for collision with the ball
+	// Update the elliptical orbit object
 	ellipticalOrbitObject.update(secondPlanet);
-	// Gravity effect from ellipticalOrbitObject
-	var dx = ellipticalOrbitObject.x - ball.x;
-	var dy = ellipticalOrbitObject.y - ball.y;
-	var distance = Math.sqrt(dx * dx + dy * dy);
-	var safeDistance = (ellipticalOrbitObject.radius + ball.radius + 50) * 2; // Doubling the safe margin to increase gravity range
-	if (distance < safeDistance) {
-		// Adjusted gravity effect to maintain a safe distance
-		var gravity = ellipticalOrbitObject.mass / (distance * distance) * (7 * 1.3); // Adjust gravity based on object
-		var gravityX = dx / distance * gravity;
-		var gravityY = dy / distance * gravity;
-		ball.velocity.x += gravityX * (1 - (safeDistance - distance) / safeDistance);
-		ball.velocity.y += gravityY * (1 - (safeDistance - distance) / safeDistance);
-	}
-	// Check for collision with the ball
-	if (ellipticalOrbitObject.intersects(ball)) {
-		// Reflect ball velocity
-		var normalX = ball.x - ellipticalOrbitObject.x;
-		var normalY = ball.y - ellipticalOrbitObject.y;
-		var normalLength = Math.sqrt(normalX * normalX + normalY * normalY);
-		normalX /= normalLength;
-		normalY /= normalLength;
-		var dotProduct = ball.velocity.x * normalX + ball.velocity.y * normalY;
-		ball.velocity.x -= 2 * dotProduct * normalX;
-		ball.velocity.y -= 2 * dotProduct * normalY;
-	}
 });
 // Touch controls for paddles
 function handleTouch(obj) {
 	var touchPos = obj.event.getLocalPosition(game);