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

/**** 
* Classes
****/ 
var Connection = Container.expand(function () {
	var self = Container.call(this);
	// Create line graphics using shape asset
	var lineGraphics = self.attachAsset('line', {
		anchorX: 0,
		anchorY: 0.5
	});
	// Set line properties
	lineGraphics.height = 2; // Thin line
	lineGraphics.alpha = 0.3; // Semi-transparent
	lineGraphics.tint = 0x4444ff; // Blue color for connections
	self.lineGraphics = lineGraphics;
	// Method to update line between two points
	self.updateLine = function (x1, y1, x2, y2) {
		var distance = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
		var angle = Math.atan2(y2 - y1, x2 - x1);
		// Position line at start point
		self.x = x1;
		self.y = y1;
		// Set line length and rotation
		self.lineGraphics.width = distance;
		self.rotation = angle;
	};
	return self;
});
var Star = Container.expand(function () {
	var self = Container.call(this);
	var starGraphics = self.attachAsset('solarSystem', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Use seeded random for scale and color
	// If seededRandom is available, use it, otherwise fallback to Math.random
	var randFunc = typeof seededRandom === "function" ? seededRandom : Math.random;
	// Generate scale using seeded random (for fallback, will be overwritten in star creation loop)
	var scale = 0.7 + randFunc() * 0.6;
	starGraphics.scaleX = scale;
	starGraphics.scaleY = scale;
	// Assign color based on size with 3 main color groups and smooth variations
	var colorVariations;
	if (scale <= 0.9) {
		// Small planets - red variations
		colorVariations = [0xff3a2a,
		// vivid red
		0xff5c4d,
		// soft red
		0xff7a6a,
		// pale red
		0xff4a2a,
		// deep red
		0xff6a3a // muted red
		];
	} else if (scale <= 1.1) {
		// Medium planets - yellow variations
		colorVariations = [0xffe066,
		// bright yellow
		0xffd700,
		// gold
		0xfff380,
		// pale yellow
		0xffe94d,
		// sun yellow
		0xfff7a1 // soft yellow
		];
	} else {
		// Large planets - blue variations
		colorVariations = [0x3a6aff,
		// vivid blue
		0x4d8cff,
		// soft blue
		0x6aaaff,
		// pale blue
		0x2a4aff,
		// deep blue
		0x3a6aff // muted blue
		];
	}
	// Set initial color using seededRandom if available, fallback to Math.random
	var currentColorIndex = Math.floor(randFunc() * colorVariations.length);
	starGraphics.tint = colorVariations[currentColorIndex];
	// Store color data for animation
	self.colorVariations = colorVariations;
	self.currentColorIndex = currentColorIndex;
	self.starGraphics = starGraphics;
	// Start color animation with smoother transitions
	self.animateColor = function () {
		var nextColorIndex = (self.currentColorIndex + 1) % self.colorVariations.length;
		tween(self.starGraphics, {
			tint: self.colorVariations[nextColorIndex]
		}, {
			duration: 3000 + randFunc() * 2000,
			// Longer, smoother transitions
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				self.currentColorIndex = nextColorIndex;
				// Restart animation loop immediately for seamless cycling
				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
****/ 
// Define the current seed (could be random or fixed for now)
var currentSeed = 99999999; // Cambia este valor para probar diferentes semillas
function makeSeededRandom(seed) {
	var m = 0x80000000; // 2**31
	var a = 1103515245;
	var c = 12345;
	var state = seed ? seed : Math.floor(Math.random() * (m - 1));
	return function () {
		state = (a * state + c) % m;
		return state / (m - 1);
	};
}
// Mostrar la semilla actual en la parte superior central
var seedText = new Text2("Semilla: " + currentSeed, {
	size: 70,
	fill: 0xFFFFFF
});
seedText.anchor.set(0.5, 0); // Centrado arriba
LK.gui.top.addChild(seedText);
// Array to store all stars
var stars = [];
// Array to store connections between stars
var connections = [];
// Create seeded random generator for this session
var seededRandom = makeSeededRandom(currentSeed);
// Generate random number of stars between 60 and 104 using seeded random
var numStars = 60 + Math.floor(seededRandom() * 45);
// Function to check if position is valid with size-based minimum distance
function isValidPosition(x, y, newStarScale) {
	// 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));
		// Calculate dynamic minimum distance based on both stars' sizes
		var existingStarSize = (star.starGraphics ? star.starGraphics.width * star.starGraphics.scaleX : 100) / 2;
		var newStarSize = 100 * newStarScale / 2; // Assuming base star size is 100px
		// Minimum distance varies based on star sizes: larger stars need more space
		var baseDist = 300; // Base minimum distance
		var sizeFactor = (existingStarSize + newStarSize) * 2; // Additional space based on combined sizes
		var requiredDistance = baseDist + sizeFactor;
		if (distance < requiredDistance) {
			return false;
		}
	}
	return true;
}
// Function to create connections between nearby stars
function createConnections() {
	// Clear existing connections
	for (var i = 0; i < connections.length; i++) {
		connections[i].destroy();
	}
	connections = [];
	var connectionRange = 800; // Maximum distance for connections
	// Check each star against every other star
	for (var i = 0; i < stars.length; i++) {
		var star1 = stars[i];
		for (var j = i + 1; j < stars.length; j++) {
			var star2 = stars[j];
			// Calculate distance between stars
			var distance = Math.sqrt(Math.pow(star2.x - star1.x, 2) + Math.pow(star2.y - star1.y, 2));
			// Create connection if within range
			if (distance <= connectionRange) {
				var connection = game.addChild(new Connection());
				connection.updateLine(star1.x, star1.y, star2.x, star2.y);
				connections.push(connection);
			}
		}
		// Create connections between nearby stars after all stars are generated
		createConnections();
	}
}
// 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 all connections positions
		for (var i = 0; i < connections.length; i++) {
			connections[i].x += deltaX;
			connections[i].y += deltaY;
		}
		lastDragX = x;
		lastDragY = y;
	}
};
game.up = function (x, y, obj) {
	isDragging = false;
};
// Create stars with natural clustering and varied placement
for (var i = 0; i < numStars; i++) {
	var attempts = 0;
	var maxAttempts = 200; // More attempts for better placement
	var validPosition = false;
	var x, y, scale;
	// Pre-generate star scale to use in position validation
	scale = 0.7 + seededRandom() * 0.6;
	// Try to find a valid position
	while (!validPosition && attempts < maxAttempts) {
		// Generate position with natural clustering tendency
		var centerX = 2048 / 2;
		var centerY = 2732 / 2;
		var angle = seededRandom() * 2 * Math.PI;
		// Create natural distribution - more stars in middle, fewer at edges
		var radiusRandom = seededRandom();
		var radius = Math.pow(radiusRandom, 1.5) * 4000; // Power curve for natural distribution
		// Add some variation to avoid perfect circles
		var radiusVariation = (seededRandom() - 0.5) * 300;
		radius += radiusVariation;
		radius = Math.max(200, Math.min(4000, radius)); // Clamp within bounds
		x = centerX + Math.cos(angle) * radius;
		y = centerY + Math.sin(angle) * radius;
		validPosition = isValidPosition(x, y, scale);
		attempts++;
	}
	// Only create star if valid position was found
	if (validPosition) {
		var star = game.addChild(new Star());
		star.x = x;
		star.y = y;
		// Apply the pre-generated scale to maintain consistency
		star.starGraphics.scaleX = scale;
		star.starGraphics.scaleY = scale;
		stars.push(star);
	} else {
		// If we couldn't find a valid position after max attempts, reduce requirements and try once more
		if (i > numStars * 0.7) {
			// Only for the last 30% of stars
			scale = 0.7; // Use smaller scale for difficult placements
			var relaxedAttempts = 0;
			while (!validPosition && relaxedAttempts < 50) {
				var centerX = 2048 / 2;
				var centerY = 2732 / 2;
				var angle = seededRandom() * 2 * Math.PI;
				var radius = 3000 + seededRandom() * 1000; // Place at outer edges
				x = centerX + Math.cos(angle) * radius;
				y = centerY + Math.sin(angle) * radius;
				validPosition = isValidPosition(x, y, scale);
				relaxedAttempts++;
			}
			if (validPosition) {
				var star = game.addChild(new Star());
				star.x = x;
				star.y = y;
				star.starGraphics.scaleX = scale;
				star.starGraphics.scaleY = scale;
				stars.push(star);
			}
		}
	}
}

===================================================================
--- original.js
+++ change.js
@@ -300,52 +300,8 @@
 		star.y = y;
 		// Apply the pre-generated scale to maintain consistency
 		star.starGraphics.scaleX = scale;
 		star.starGraphics.scaleY = scale;
-		// Re-assign color variations and tint based on the actual scale and seeded random
-		var colorVariations;
-		if (scale <= 0.9) {
-			// Small planets - red variations
-			colorVariations = [0xff3a2a,
-			// vivid red
-			0xff5c4d,
-			// soft red
-			0xff7a6a,
-			// pale red
-			0xff4a2a,
-			// deep red
-			0xff6a3a // muted red
-			];
-		} else if (scale <= 1.1) {
-			// Medium planets - yellow variations
-			colorVariations = [0xffe066,
-			// bright yellow
-			0xffd700,
-			// gold
-			0xfff380,
-			// pale yellow
-			0xffe94d,
-			// sun yellow
-			0xfff7a1 // soft yellow
-			];
-		} else {
-			// Large planets - blue variations
-			colorVariations = [0x3a6aff,
-			// vivid blue
-			0x4d8cff,
-			// soft blue
-			0x6aaaff,
-			// pale blue
-			0x2a4aff,
-			// deep blue
-			0x3a6aff // muted blue
-			];
-		}
-		var randFunc = typeof seededRandom === "function" ? seededRandom : Math.random;
-		var currentColorIndex = Math.floor(randFunc() * colorVariations.length);
-		star.starGraphics.tint = colorVariations[currentColorIndex];
-		star.colorVariations = colorVariations;
-		star.currentColorIndex = currentColorIndex;
 		stars.push(star);
 	} else {
 		// If we couldn't find a valid position after max attempts, reduce requirements and try once more
 		if (i > numStars * 0.7) {
@@ -367,52 +323,8 @@
 				star.x = x;
 				star.y = y;
 				star.starGraphics.scaleX = scale;
 				star.starGraphics.scaleY = scale;
-				// Re-assign color variations and tint based on the actual scale and seeded random
-				var colorVariations;
-				if (scale <= 0.9) {
-					// Small planets - red variations
-					colorVariations = [0xff3a2a,
-					// vivid red
-					0xff5c4d,
-					// soft red
-					0xff7a6a,
-					// pale red
-					0xff4a2a,
-					// deep red
-					0xff6a3a // muted red
-					];
-				} else if (scale <= 1.1) {
-					// Medium planets - yellow variations
-					colorVariations = [0xffe066,
-					// bright yellow
-					0xffd700,
-					// gold
-					0xfff380,
-					// pale yellow
-					0xffe94d,
-					// sun yellow
-					0xfff7a1 // soft yellow
-					];
-				} else {
-					// Large planets - blue variations
-					colorVariations = [0x3a6aff,
-					// vivid blue
-					0x4d8cff,
-					// soft blue
-					0x6aaaff,
-					// pale blue
-					0x2a4aff,
-					// deep blue
-					0x3a6aff // muted blue
-					];
-				}
-				var randFunc = typeof seededRandom === "function" ? seededRandom : Math.random;
-				var currentColorIndex = Math.floor(randFunc() * colorVariations.length);
-				star.starGraphics.tint = colorVariations[currentColorIndex];
-				star.colorVariations = colorVariations;
-				star.currentColorIndex = currentColorIndex;
 				stars.push(star);
 			}
 		}
 	}