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

/**** 
* Classes
****/ 
var Star = Container.expand(function () {
	var self = Container.call(this);
	var starGraphics = self.attachAsset('solarSystem', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Generate random scale between 0.7 and 1.3
	var scale = 0.7 + Math.random() * 0.6;
	starGraphics.scaleX = scale;
	starGraphics.scaleY = scale;
	// Assign color based on size with 5 variations each
	var colorVariations;
	if (scale <= 0.9) {
		// Small stars - red variations (cooler)
		colorVariations = [0xff2222, 0xff3333, 0xff4444, 0xff5555, 0xff6666];
	} else if (scale <= 1.1) {
		// Medium stars - yellow variations (like our sun)
		colorVariations = [0xffcc22, 0xffdd33, 0xffee44, 0xffff55, 0xffff66];
	} else {
		// Large stars - blue variations (hotter)
		colorVariations = [0x2222ff, 0x3333ff, 0x4444ff, 0x5555ff, 0x6666ff];
	}
	// Set initial color
	var currentColorIndex = Math.floor(Math.random() * colorVariations.length);
	starGraphics.tint = colorVariations[currentColorIndex];
	// Store color data for animation
	self.colorVariations = colorVariations;
	self.currentColorIndex = currentColorIndex;
	self.starGraphics = starGraphics;
	// Start color animation
	self.animateColor = function () {
		var nextColorIndex = (self.currentColorIndex + 1) % self.colorVariations.length;
		tween(self.starGraphics, {
			tint: self.colorVariations[nextColorIndex]
		}, {
			duration: 2000 + Math.random() * 1000,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				self.currentColorIndex = nextColorIndex;
				self.animateColor();
			}
		});
	};
	// Bump animation: smoothly scale up and then back to original in continuous loop
	self.bump = function () {
		// Cancel any ongoing scale tweens
		tween.stop(self.starGraphics, {
			scaleX: true,
			scaleY: true
		});
		var originalScaleX = self.starGraphics.scaleX;
		var originalScaleY = self.starGraphics.scaleY;
		// Scale up
		tween(self.starGraphics, {
			scaleX: originalScaleX * 1.15,
			scaleY: originalScaleY * 1.15
		}, {
			duration: 1000,
			easing: tween.linear,
			onFinish: function onFinish() {
				// Scale back down
				tween(self.starGraphics, {
					scaleX: originalScaleX,
					scaleY: originalScaleY
				}, {
					duration: 1000,
					easing: tween.linear,
					onFinish: function onFinish() {
						// Loop the animation by calling bump again
						self.bump();
					}
				});
			}
		});
	};
	// Start the animation
	self.animateColor();
	// Optionally, trigger bump on creation for a lively effect
	self.bump();
	return self;
});

/**** 
* Initialize Game
****/ 
// Create star object and position at center
var game = new LK.Game({
	backgroundColor: 0x000000
});

/**** 
* Game Code
****/ 
// Camera position for navigation
var cameraX = 0;
var cameraY = 0;
var isDragging = false;
var lastDragX = 0;
var lastDragY = 0;
/**** 
* Inicialización de objetos
****/ 
// Array to store all stars
var stars = [];
// Generate random number of stars between 5 and 8
var numStars = 60 + Math.floor(Math.random() * 45);
// Function to check if position is valid with improved minimum distance between planets
function isValidPosition(x, y, minDistance) {
	var _loop = function _loop() {
			star = stars[i];
			distance = Math.sqrt(Math.pow(x - star.x, 2) + Math.pow(y - star.y, 2)); // Consider the actual size of both stars for more accurate spacing
			starSize = star.starGraphics ? star.starGraphics.width * star.starGraphics.scaleX / 2 : 50;
			requiredDistance = minDistance + starSize;
			if (distance < requiredDistance) {
				return {
					v: false
				};
			}
			// Create universe limiter
			universeLimiter = game.addChild(LK.getAsset('universeLimit', {
				anchorX: 0.5,
				anchorY: 0.5,
				alpha: 0.3
			})); // Position universe limiter at center
			universeLimiter.x = 2048 / 2;
			universeLimiter.y = 2732 / 2;
			// Add continuous rotation animation
			function rotateUniverseLimiter() {
				tween(universeLimiter, {
					rotation: universeLimiter.rotation + Math.PI * 2
				}, {
					duration: 30000,
					easing: tween.linear,
					onFinish: function onFinish() {
						// Reset rotation to prevent accumulation and continue loop
						universeLimiter.rotation = 0;
						rotateUniverseLimiter();
					}
				});
			}
			// Start rotation animation
			rotateUniverseLimiter();
			// Drag navigation system
			game.down = function (x, y, obj) {
				isDragging = true;
				lastDragX = x;
				lastDragY = y;
			};
			game.move = function (x, y, obj) {
				if (isDragging) {
					var deltaX = x - lastDragX;
					var deltaY = y - lastDragY;
					// Update camera position (inverted for natural drag feel)
					cameraX -= deltaX;
					cameraY -= deltaY;
					// Update all stars positions
					for (var i = 0; i < stars.length; i++) {
						stars[i].x += deltaX;
						stars[i].y += deltaY;
					}
					// Update universe limiter position
					universeLimiter.x += deltaX;
					universeLimiter.y += deltaY;
					lastDragX = x;
					lastDragY = y;
				}
			};
			game.up = function (x, y, obj) {
				isDragging = false;
			};
		},
		star,
		distance,
		starSize,
		requiredDistance,
		universeLimiter,
		_ret;
	// Check distance from all existing stars
	for (var i = 0; i < stars.length; i++) {
		_ret = _loop();
		if (_ret) return _ret.v;
	}
	return true;
}
// Create stars with improved minimum distance constraint
var minPlanetDistance = 800; // Increased minimum distance between planets
for (var i = 0; i < numStars; i++) {
	var attempts = 0;
	var maxAttempts = 150; // Increased attempts for better placement
	var validPosition = false;
	var x, y;
	// Try to find a valid position
	while (!validPosition && attempts < maxAttempts) {
		// Generate random position within circular area of 4000px radius from center
		var centerX = 2048 / 2;
		var centerY = 2732 / 2;
		var angle = Math.random() * 2 * Math.PI;
		var radius = Math.random() * 4000;
		x = centerX + Math.cos(angle) * radius;
		y = centerY + Math.sin(angle) * radius;
		validPosition = isValidPosition(x, y, minPlanetDistance);
		attempts++;
	}
	// Only create star if valid position was found
	if (validPosition) {
		var star = game.addChild(new Star());
		star.x = x;
		star.y = y;
		stars.push(star);
	} else {
		// If we couldn't find a valid position after max attempts, skip this star
		console.log("Could not place star " + i + " after " + maxAttempts + " attempts");
	}
}

===================================================================
--- original.js
+++ change.js
@@ -113,43 +113,81 @@
 // Generate random number of stars between 5 and 8
 var numStars = 60 + Math.floor(Math.random() * 45);
 // Function to check if position is valid with improved minimum distance between planets
 function isValidPosition(x, y, minDistance) {
-	// Check distance from all existing stars
-	for (var i = 0; i < stars.length; i++) {
-		var star = stars[i];
-		var distance = Math.sqrt(Math.pow(x - star.x, 2) + Math.pow(y - star.y, 2));
-		// Consider the actual size of both stars for more accurate spacing
-		var starSize = star.starGraphics ? star.starGraphics.width * star.starGraphics.scaleX / 2 : 50;
-		var requiredDistance = minDistance + starSize;
-		if (distance < requiredDistance) {
-			return false;
-		}
-		// Drag navigation system
-		game.down = function (x, y, obj) {
-			isDragging = true;
-			lastDragX = x;
-			lastDragY = y;
-		};
-		game.move = function (x, y, obj) {
-			if (isDragging) {
-				var deltaX = x - lastDragX;
-				var deltaY = y - lastDragY;
-				// Update camera position (inverted for natural drag feel)
-				cameraX -= deltaX;
-				cameraY -= deltaY;
-				// Update all stars positions
-				for (var i = 0; i < stars.length; i++) {
-					stars[i].x += deltaX;
-					stars[i].y += deltaY;
-				}
+	var _loop = function _loop() {
+			star = stars[i];
+			distance = Math.sqrt(Math.pow(x - star.x, 2) + Math.pow(y - star.y, 2)); // Consider the actual size of both stars for more accurate spacing
+			starSize = star.starGraphics ? star.starGraphics.width * star.starGraphics.scaleX / 2 : 50;
+			requiredDistance = minDistance + starSize;
+			if (distance < requiredDistance) {
+				return {
+					v: false
+				};
+			}
+			// Create universe limiter
+			universeLimiter = game.addChild(LK.getAsset('universeLimit', {
+				anchorX: 0.5,
+				anchorY: 0.5,
+				alpha: 0.3
+			})); // Position universe limiter at center
+			universeLimiter.x = 2048 / 2;
+			universeLimiter.y = 2732 / 2;
+			// Add continuous rotation animation
+			function rotateUniverseLimiter() {
+				tween(universeLimiter, {
+					rotation: universeLimiter.rotation + Math.PI * 2
+				}, {
+					duration: 30000,
+					easing: tween.linear,
+					onFinish: function onFinish() {
+						// Reset rotation to prevent accumulation and continue loop
+						universeLimiter.rotation = 0;
+						rotateUniverseLimiter();
+					}
+				});
+			}
+			// Start rotation animation
+			rotateUniverseLimiter();
+			// Drag navigation system
+			game.down = function (x, y, obj) {
+				isDragging = true;
 				lastDragX = x;
 				lastDragY = y;
-			}
-		};
-		game.up = function (x, y, obj) {
-			isDragging = false;
-		};
+			};
+			game.move = function (x, y, obj) {
+				if (isDragging) {
+					var deltaX = x - lastDragX;
+					var deltaY = y - lastDragY;
+					// Update camera position (inverted for natural drag feel)
+					cameraX -= deltaX;
+					cameraY -= deltaY;
+					// Update all stars positions
+					for (var i = 0; i < stars.length; i++) {
+						stars[i].x += deltaX;
+						stars[i].y += deltaY;
+					}
+					// Update universe limiter position
+					universeLimiter.x += deltaX;
+					universeLimiter.y += deltaY;
+					lastDragX = x;
+					lastDragY = y;
+				}
+			};
+			game.up = function (x, y, obj) {
+				isDragging = false;
+			};
+		},
+		star,
+		distance,
+		starSize,
+		requiredDistance,
+		universeLimiter,
+		_ret;
+	// Check distance from all existing stars
+	for (var i = 0; i < stars.length; i++) {
+		_ret = _loop();
+		if (_ret) return _ret.v;
 	}
 	return true;
 }
 // Create stars with improved minimum distance constraint