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

/**** 
* Classes
****/ 
var Bomb = Container.expand(function () {
	var self = Container.call(this);
	var bombGraphics = self.attachAsset('bomb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.timer = 120; // 2 seconds at 60fps
	self.active = false;
	self.activate = function () {
		self.active = true;
	};
	self.update = function () {
		if (!self.active) return;
		self.timer--;
		if (self.timer <= 0) {
			self.active = false;
			onBombExplode(self.x, self.y);
		}
	};
	return self;
});
var Explosion = Container.expand(function () {
	var self = Container.call(this);
	var explosionGraphics = self.attachAsset('explosion', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.lifetime = 60; // 1 second
	self.maxLifetime = 60;
	self.update = function () {
		self.lifetime--;
		var alpha = self.lifetime / self.maxLifetime;
		explosionGraphics.alpha = alpha;
		if (self.lifetime <= 0) {
			self.destroy();
			var index = explosions.indexOf(self);
			if (index > -1) explosions.splice(index, 1);
		}
	};
	return self;
});
var Meteor = Container.expand(function () {
	var self = Container.call(this);
	var meteorGraphics = self.attachAsset('meteor', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.targetX = 0;
	self.targetY = 0;
	self.speed = 8;
	self.active = false;
	self.launch = function (targetX, targetY) {
		self.targetX = targetX;
		self.targetY = targetY;
		self.active = true;
		var angle = Math.atan2(targetY - self.y, targetX - self.x);
		self.velocityX = Math.cos(angle) * self.speed;
		self.velocityY = Math.sin(angle) * self.speed;
	};
	self.update = function () {
		if (!self.active) return;
		self.x += self.velocityX;
		self.y += self.velocityY;
		var distance = Math.sqrt(Math.pow(self.targetX - self.x, 2) + Math.pow(self.targetY - self.y, 2));
		if (distance < 30) {
			self.active = false;
			onMeteorHit(self.x, self.y);
		}
	};
	return self;
});
var Moon = Container.expand(function () {
	var self = Container.call(this);
	var moonGraphics = self.attachAsset('moon', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.targetX = 0;
	self.targetY = 0;
	self.speed = 6;
	self.active = false;
	self.launch = function (targetX, targetY) {
		self.targetX = targetX;
		self.targetY = targetY;
		self.active = true;
		var angle = Math.atan2(targetY - self.y, targetX - self.x);
		self.velocityX = Math.cos(angle) * self.speed;
		self.velocityY = Math.sin(angle) * self.speed;
	};
	self.update = function () {
		if (!self.active) return;
		self.x += self.velocityX;
		self.y += self.velocityY;
		var distance = Math.sqrt(Math.pow(self.targetX - self.x, 2) + Math.pow(self.targetY - self.y, 2));
		if (distance < 40) {
			self.active = false;
			onMoonHit(self.x, self.y);
		}
	};
	return self;
});
var Planet = Container.expand(function (planetType) {
	var self = Container.call(this);
	self.planetType = planetType || 'planet';
	var planetGraphics = self.attachAsset(self.planetType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Different planets have different health values
	switch (self.planetType) {
		case 'mercury':
			self.health = 60;
			self.maxHealth = 100;
			break;
		case 'venus':
			self.health = 95;
			self.maxHealth = 100;
			break;
		case 'mars':
			self.health = 85;
			self.maxHealth = 100;
			break;
		case 'jupiter':
			self.health = 350;
			self.maxHealth = 350;
			break;
		case 'sun':
			self.health = 1000;
			self.maxHealth = 1000;
			break;
		default:
			self.health = 100;
			self.maxHealth = 100;
			break;
	}
	self.destructionZones = [];
	self.takeDamage = function (amount, x, y) {
		self.health -= amount;
		var isDestroyed = self.health <= 0;
		if (isDestroyed) {
			self.health = 0;
		}
		// Add destruction zone
		var destructionZone = {
			x: x - self.x,
			y: y - self.y,
			size: amount * 2
		};
		self.destructionZones.push(destructionZone);
		// Update planet appearance based on health
		var healthPercent = self.health / self.maxHealth;
		if (isDestroyed) {
			planetGraphics.tint = 0x8D6E63; // Brown for destroyed
		} else if (healthPercent > 0.7) {
			planetGraphics.tint = 0x4CAF50; // Green
		} else if (healthPercent > 0.4) {
			planetGraphics.tint = 0xFFEB3B; // Yellow
		} else {
			planetGraphics.tint = 0xFF5722; // Orange
		}
		return isDestroyed;
	};
	return self;
});
var PlanetButton = Container.expand(function (planetType) {
	var self = Container.call(this);
	var buttonGraphics = self.attachAsset('planetButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.planetType = planetType;
	self.selected = false;
	// Add planet icon
	var planetIcon = self.attachAsset(planetType, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.3,
		scaleY: 0.3
	});
	// Add planet name text
	var planetName = planetType.charAt(0).toUpperCase() + planetType.slice(1);
	var nameText = new Text2(planetName, {
		size: 30,
		fill: 0xFFFFFF
	});
	nameText.anchor.set(0.5, 0);
	nameText.y = 80;
	self.addChild(nameText);
	self.setSelected = function (selected) {
		self.selected = selected;
		if (selected) {
			buttonGraphics.tint = 0xFFFFFF;
		} else {
			buttonGraphics.tint = 0x888888;
		}
	};
	self.down = function (x, y, obj) {
		selectPlanet(self.planetType);
	};
	return self;
});
var WeaponButton = Container.expand(function (weaponType) {
	var self = Container.call(this);
	var buttonGraphics = self.attachAsset('weaponButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.weaponType = weaponType;
	self.selected = false;
	// Add weapon icon
	var iconAsset;
	switch (weaponType) {
		case 'meteor':
			iconAsset = 'meteor';
			break;
		case 'bomb':
			iconAsset = 'bomb';
			break;
		case 'laser':
			iconAsset = 'laser';
			break;
		case 'blackhole':
			iconAsset = 'blackhole';
			break;
		case 'moon':
			iconAsset = 'moon';
			break;
	}
	var icon = self.attachAsset(iconAsset, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.7,
		scaleY: 0.7
	});
	self.setSelected = function (selected) {
		self.selected = selected;
		if (selected) {
			buttonGraphics.tint = 0xFFFFFF;
		} else {
			buttonGraphics.tint = 0x888888;
		}
	};
	self.down = function (x, y, obj) {
		selectWeapon(self.weaponType);
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x000011
});

/**** 
* Game Code
****/ 
var planet;
var meteors = [];
var moons = [];
var bombs = [];
var explosions = [];
var weaponButtons = [];
var planetButtons = [];
var selectedWeapon = 'meteor';
var selectedPlanetType = 'earth';
var planetDestroyed = false;
var gameStarted = false;
var level = 0; // Always start at 0, load from storage only when explicitly saved
var jupiterRegenTimer = 0;
var jupiterRegenInterval = 60; // 1 second at 60fps
// Base weapon cooldowns (in ticks at 60fps)
var baseCooldowns = {
	meteor: 120,
	// 2 seconds
	bomb: 180,
	// 3 seconds
	laser: 150,
	// 2.5 seconds
	blackhole: 300,
	// 5 seconds
	moon: 420 // 7 seconds
};
var lastWeaponUse = {
	meteor: -999,
	bomb: -999,
	laser: -999,
	blackhole: -999,
	moon: -999
};
var gameTicks = 0;
var coins = 0;
var storeOpen = false;
var storeElements = [];
// Weapon upgrade levels and costs
var weaponUpgrades = {
	meteor: 0,
	bomb: 0,
	laser: 0,
	blackhole: 0,
	moon: 0
};
// Upgrade costs (increases with each level)
var upgradeCosts = {
	meteor: [100, 200, 300, 500, 800],
	bomb: [150, 300, 450, 750, 1200],
	laser: [125, 250, 375, 625, 1000],
	blackhole: [250, 500, 750, 1250, 2000],
	moon: [300, 600, 900, 1500, 2400]
};
// Calculate actual cooldowns based on upgrades
var weaponCooldowns = {
	meteor: Math.max(30, baseCooldowns.meteor - weaponUpgrades.meteor * 15),
	bomb: Math.max(45, baseCooldowns.bomb - weaponUpgrades.bomb * 25),
	laser: Math.max(30, baseCooldowns.laser - weaponUpgrades.laser * 20),
	blackhole: Math.max(90, baseCooldowns.blackhole - weaponUpgrades.blackhole * 40),
	moon: Math.max(120, baseCooldowns.moon - weaponUpgrades.moon * 50)
};
// UI Elements
var healthTxt = new Text2('Planet Health: 100%', {
	size: 60,
	fill: 0xFFFFFF
});
healthTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(healthTxt);
// Level display
var levelTxt = new Text2('Level: 0', {
	size: 60,
	fill: 0xFFFFFF
});
levelTxt.anchor.set(0.5, 0);
levelTxt.y = 70;
LK.gui.top.addChild(levelTxt);
// Coins display
var coinsTxt = new Text2('Coins: 0', {
	size: 60,
	fill: 0xFFD700
});
coinsTxt.anchor.set(0.5, 0);
coinsTxt.y = 140;
LK.gui.top.addChild(coinsTxt);
// Create planet selection title
var planetSelectTitle = new Text2('Select Planet to Destroy', {
	size: 80,
	fill: 0xFFFFFF
});
planetSelectTitle.anchor.set(0.5, 0.5);
planetSelectTitle.x = 2048 / 2;
planetSelectTitle.y = 400;
game.addChild(planetSelectTitle);
// Create planets section title
var planetsTitle = new Text2('PLANETS', {
	size: 60,
	fill: 0xFFFFFF
});
planetsTitle.anchor.set(0.5, 0.5);
planetsTitle.x = 2048 / 2;
planetsTitle.y = 2732 / 2 - 200;
game.addChild(planetsTitle);
// Create planet selection buttons
var planetTypes = ['earth', 'mercury', 'venus', 'mars', 'jupiter'];
var starTypes = ['sun'];
for (var i = 0; i < planetTypes.length; i++) {
	var planetButton = new PlanetButton(planetTypes[i]);
	planetButton.x = 2048 / 2 + (i - 2) * 200;
	planetButton.y = 2732 / 2 - 100;
	// Lock Jupiter if level is less than 10
	if (planetTypes[i] === 'jupiter' && level < 10) {
		planetButton.alpha = 0.3;
		planetButton.interactive = false;
	}
	planetButtons.push(planetButton);
	game.addChild(planetButton);
}
// Create stars section title
var starsTitle = new Text2('STARS', {
	size: 60,
	fill: 0xFFD700
});
starsTitle.anchor.set(0.5, 0.5);
starsTitle.x = 2048 / 2;
starsTitle.y = 2732 / 2 + 50;
game.addChild(starsTitle);
// Create star selection buttons
for (var i = 0; i < starTypes.length; i++) {
	var starButton = new PlanetButton(starTypes[i]);
	starButton.x = 2048 / 2 + (i - 0) * 200;
	starButton.y = 2732 / 2 + 150;
	// Lock Sun if level is less than 50
	if (starTypes[i] === 'sun' && level < 50) {
		starButton.alpha = 0.3;
		starButton.interactive = false;
	}
	planetButtons.push(starButton);
	game.addChild(starButton);
}
// Initial planet selection will be done by player
// Initialize UI displays with stored values
levelTxt.setText('Level: ' + level);
coinsTxt.setText('Coins: ' + coins);
// Create start game button
var startButton = new Text2('START GAME', {
	size: 60,
	fill: 0x00FF00
});
startButton.anchor.set(0.5, 0.5);
startButton.x = 2048 / 2 - 200;
startButton.y = 2732 / 2 + 200;
game.addChild(startButton);
startButton.down = function (x, y, obj) {
	if (selectedPlanetType && !gameStarted) {
		startGame();
	}
};
// Create store button
var storeButton = new Text2('STORE', {
	size: 60,
	fill: 0xFFD700
});
storeButton.anchor.set(0.5, 0.5);
storeButton.x = 2048 / 2 + 200;
storeButton.y = 2732 / 2 + 200;
game.addChild(storeButton);
storeButton.down = function (x, y, obj) {
	if (!gameStarted) {
		openStore();
	}
};
// Create weapon selection buttons
var weaponTypes = ['meteor', 'bomb', 'laser', 'blackhole', 'moon'];
for (var i = 0; i < weaponTypes.length; i++) {
	var button = new WeaponButton(weaponTypes[i]);
	button.x = 150 + i * 140;
	button.y = 2732 - 150;
	weaponButtons.push(button);
	game.addChild(button);
}
// Select initial weapon
selectWeapon('meteor');
// Don't load game data automatically on startup - players must click LOAD
// Show main menu elements after all UI elements are created
showMainMenu();
function selectPlanet(planetType) {
	// Check if Jupiter is locked
	if (planetType === 'jupiter' && level < 10) {
		return; // Don't select if locked
	}
	// Check if Sun is locked
	if (planetType === 'sun' && level < 50) {
		return; // Don't select if locked
	}
	selectedPlanetType = planetType;
	for (var i = 0; i < planetButtons.length; i++) {
		planetButtons[i].setSelected(planetButtons[i].planetType === planetType);
	}
}
function startGame() {
	gameStarted = true;
	// Hide planet selection UI
	for (var i = 0; i < planetButtons.length; i++) {
		planetButtons[i].visible = false;
	}
	// Remove title and start button
	planetSelectTitle.visible = false;
	planetsTitle.visible = false;
	starsTitle.visible = false;
	startButton.visible = false;
	// Hide store button during gameplay
	storeButton.visible = false;
	// Create selected planet
	planet = game.addChild(new Planet(selectedPlanetType));
	planet.x = 2048 / 2;
	planet.y = 2732 / 2;
	// Reset Jupiter regeneration timer
	jupiterRegenTimer = 0;
}
function selectWeapon(weaponType) {
	selectedWeapon = weaponType;
	for (var i = 0; i < weaponButtons.length; i++) {
		weaponButtons[i].setSelected(weaponButtons[i].weaponType === weaponType);
	}
}
function onMeteorHit(x, y) {
	LK.getSound('meteorHit').play();
	var destroyed = planet.takeDamage(15, x, y);
	createExplosion(x, y);
	if (destroyed && !planetDestroyed) {
		planetDestroyed = true;
		// Add levels based on planet type
		var levelsGained = 0;
		if (planet.planetType === 'earth') {
			levelsGained = 5;
		} else if (planet.planetType === 'mercury') {
			levelsGained = 1;
		} else if (planet.planetType === 'venus') {
			levelsGained = 3;
		} else if (planet.planetType === 'mars') {
			levelsGained = 2;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 10;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (50) with this gain
		var maxLevel = 50;
		var oldLevel = level;
		if (level < maxLevel) {
			var actualLevelsGained = Math.min(levelsGained, maxLevel - level);
			level += actualLevelsGained;
			// If we just reached max level, award bonus coins
			if (oldLevel < maxLevel && level >= maxLevel) {
				coins += 3500; // Max level bonus
			}
			// Award normal coins for levels gained
			coins += actualLevelsGained * 100;
		} else {
			// Already at max level, only award coins (no level progression)
			coins += levelsGained * 100;
		}
		storage.coins = coins;
		storage.level = level;
		// Update health display immediately when game is over
		var planetName = planet.planetType === 'earth' ? 'Earth' : planet.planetType.charAt(0).toUpperCase() + planet.planetType.slice(1);
		healthTxt.setText(planetName + ': 0% Health');
		LK.setTimeout(function () {
			resetToLevelSelection();
		}, 2000);
	}
}
function onMoonHit(x, y) {
	LK.getSound('moonHit').play();
	var destroyed = planet.takeDamage(50, x, y);
	createExplosion(x, y);
	if (destroyed && !planetDestroyed) {
		planetDestroyed = true;
		// Add levels based on planet type
		var levelsGained = 0;
		if (planet.planetType === 'earth') {
			levelsGained = 5;
		} else if (planet.planetType === 'mercury') {
			levelsGained = 1;
		} else if (planet.planetType === 'venus') {
			levelsGained = 3;
		} else if (planet.planetType === 'mars') {
			levelsGained = 2;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 10;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (50) with this gain
		var maxLevel = 50;
		var oldLevel = level;
		if (level < maxLevel) {
			var actualLevelsGained = Math.min(levelsGained, maxLevel - level);
			level += actualLevelsGained;
			// If we just reached max level, award bonus coins
			if (oldLevel < maxLevel && level >= maxLevel) {
				coins += 3500; // Max level bonus
			}
			// Award normal coins for levels gained
			coins += actualLevelsGained * 100;
		} else {
			// Already at max level, only award coins (no level progression)
			coins += levelsGained * 100;
		}
		storage.coins = coins;
		storage.level = level;
		// Update health display immediately when game is over
		var planetName = planet.planetType === 'earth' ? 'Earth' : planet.planetType.charAt(0).toUpperCase() + planet.planetType.slice(1);
		healthTxt.setText(planetName + ': 0% Health');
		LK.setTimeout(function () {
			resetToLevelSelection();
		}, 2000);
	}
}
function onBombExplode(x, y) {
	LK.getSound('bombExplode').play();
	var destroyed = planet.takeDamage(25, x, y);
	createExplosion(x, y);
	// Create multiple smaller explosions for effect
	for (var i = 0; i < 3; i++) {
		var offsetX = (Math.random() - 0.5) * 100;
		var offsetY = (Math.random() - 0.5) * 100;
		createExplosion(x + offsetX, y + offsetY);
	}
	if (destroyed && !planetDestroyed) {
		planetDestroyed = true;
		// Add levels based on planet type
		var levelsGained = 0;
		if (planet.planetType === 'earth') {
			levelsGained = 5;
		} else if (planet.planetType === 'mercury') {
			levelsGained = 1;
		} else if (planet.planetType === 'venus') {
			levelsGained = 3;
		} else if (planet.planetType === 'mars') {
			levelsGained = 2;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 10;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (50) with this gain
		var maxLevel = 50;
		var oldLevel = level;
		if (level < maxLevel) {
			var actualLevelsGained = Math.min(levelsGained, maxLevel - level);
			level += actualLevelsGained;
			// If we just reached max level, award bonus coins
			if (oldLevel < maxLevel && level >= maxLevel) {
				coins += 3500; // Max level bonus
			}
			// Award normal coins for levels gained
			coins += actualLevelsGained * 100;
		} else {
			// Already at max level, only award coins (no level progression)
			coins += levelsGained * 100;
		}
		storage.coins = coins;
		storage.level = level;
		// Update health display immediately when game is over
		var planetName = planet.planetType === 'earth' ? 'Earth' : planet.planetType.charAt(0).toUpperCase() + planet.planetType.slice(1);
		healthTxt.setText(planetName + ': 0% Health');
		LK.setTimeout(function () {
			resetToLevelSelection();
		}, 2000);
	}
}
function onLaserFire(startX, startY, endX, endY) {
	LK.getSound('laserFire').play();
	var destroyed = planet.takeDamage(20, endX, endY);
	createExplosion(endX, endY);
	if (destroyed && !planetDestroyed) {
		planetDestroyed = true;
		// Add levels based on planet type
		var levelsGained = 0;
		if (planet.planetType === 'earth') {
			levelsGained = 5;
		} else if (planet.planetType === 'mercury') {
			levelsGained = 1;
		} else if (planet.planetType === 'venus') {
			levelsGained = 3;
		} else if (planet.planetType === 'mars') {
			levelsGained = 2;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 10;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (50) with this gain
		var maxLevel = 50;
		var oldLevel = level;
		if (level < maxLevel) {
			var actualLevelsGained = Math.min(levelsGained, maxLevel - level);
			level += actualLevelsGained;
			// If we just reached max level, award bonus coins
			if (oldLevel < maxLevel && level >= maxLevel) {
				coins += 3500; // Max level bonus
			}
			// Award normal coins for levels gained
			coins += actualLevelsGained * 100;
		} else {
			// Already at max level, only award coins (no level progression)
			coins += levelsGained * 100;
		}
		storage.coins = coins;
		storage.level = level;
		// Update health display immediately when game is over
		var planetName = planet.planetType === 'earth' ? 'Earth' : planet.planetType.charAt(0).toUpperCase() + planet.planetType.slice(1);
		healthTxt.setText(planetName + ': 0% Health');
		LK.setTimeout(function () {
			resetToLevelSelection();
		}, 2000);
	}
}
function onBlackholeActivate(x, y) {
	LK.getSound('blackholeActivate').play();
	var destroyed = planet.takeDamage(30, x, y);
	createExplosion(x, y);
	if (destroyed && !planetDestroyed) {
		planetDestroyed = true;
		// Add levels based on planet type
		var levelsGained = 0;
		if (planet.planetType === 'earth') {
			levelsGained = 5;
		} else if (planet.planetType === 'mercury') {
			levelsGained = 1;
		} else if (planet.planetType === 'venus') {
			levelsGained = 3;
		} else if (planet.planetType === 'mars') {
			levelsGained = 2;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 10;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (50) with this gain
		var maxLevel = 50;
		var oldLevel = level;
		if (level < maxLevel) {
			var actualLevelsGained = Math.min(levelsGained, maxLevel - level);
			level += actualLevelsGained;
			// If we just reached max level, award bonus coins
			if (oldLevel < maxLevel && level >= maxLevel) {
				coins += 3500; // Max level bonus
			}
			// Award normal coins for levels gained
			coins += actualLevelsGained * 100;
		} else {
			// Already at max level, only award coins (no level progression)
			coins += levelsGained * 100;
		}
		storage.coins = coins;
		storage.level = level;
		// Update health display immediately when game is over
		var planetName = planet.planetType === 'earth' ? 'Earth' : planet.planetType.charAt(0).toUpperCase() + planet.planetType.slice(1);
		healthTxt.setText(planetName + ': 0% Health');
		LK.setTimeout(function () {
			resetToLevelSelection();
		}, 2000);
	}
}
function createExplosion(x, y) {
	var explosion = new Explosion();
	explosion.x = x;
	explosion.y = y;
	explosions.push(explosion);
	game.addChild(explosion);
}
function openStore() {
	storeOpen = true;
	hideMainMenu();
	// Create store background
	var storeBg = LK.getAsset('planetButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 12,
		scaleY: 15
	});
	storeBg.x = 2048 / 2;
	storeBg.y = 2732 / 2;
	storeBg.tint = 0x333366;
	game.addChild(storeBg);
	storeElements.push(storeBg);
	// Store title
	var storeTitle = new Text2('WEAPON UPGRADES', {
		size: 80,
		fill: 0xFFFFFF
	});
	storeTitle.anchor.set(0.5, 0.5);
	storeTitle.x = 2048 / 2;
	storeTitle.y = 300;
	game.addChild(storeTitle);
	storeElements.push(storeTitle);
	// Create upgrade buttons for each weapon
	var weaponNames = ['meteor', 'bomb', 'laser', 'blackhole', 'moon'];
	for (var i = 0; i < weaponNames.length; i++) {
		createUpgradeButton(weaponNames[i], i);
	}
	// Close store button
	var closeButton = new Text2('CLOSE', {
		size: 60,
		fill: 0xFF5555
	});
	closeButton.anchor.set(0.5, 0.5);
	closeButton.x = 2048 / 2;
	closeButton.y = 2400;
	game.addChild(closeButton);
	storeElements.push(closeButton);
	closeButton.down = function () {
		closeStore();
	};
}
function createUpgradeButton(weaponType, index) {
	var yPos = 600 + index * 300;
	var currentLevel = weaponUpgrades[weaponType];
	var maxLevel = 5;
	var cost = currentLevel < maxLevel ? upgradeCosts[weaponType][currentLevel] : 0;
	// Weapon icon
	var icon = LK.getAsset(weaponType, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8
	});
	icon.x = 400;
	icon.y = yPos;
	game.addChild(icon);
	storeElements.push(icon);
	// Weapon name and level
	var weaponName = weaponType.charAt(0).toUpperCase() + weaponType.slice(1);
	var nameText = new Text2(weaponName + ' (Level ' + currentLevel + '/' + maxLevel + ')', {
		size: 50,
		fill: 0xFFFFFF
	});
	nameText.anchor.set(0, 0.5);
	nameText.x = 550;
	nameText.y = yPos - 30;
	game.addChild(nameText);
	storeElements.push(nameText);
	// Cooldown info
	var currentCooldown = Math.max(30, baseCooldowns[weaponType] - currentLevel * getUpgradeReduction(weaponType));
	var nextCooldown = currentLevel < maxLevel ? Math.max(30, baseCooldowns[weaponType] - (currentLevel + 1) * getUpgradeReduction(weaponType)) : currentCooldown;
	var cooldownText = new Text2('Cooldown: ' + (currentCooldown / 60).toFixed(1) + 's', {
		size: 40,
		fill: 0xCCCCCC
	});
	cooldownText.anchor.set(0, 0.5);
	cooldownText.x = 550;
	cooldownText.y = yPos + 30;
	game.addChild(cooldownText);
	storeElements.push(cooldownText);
	// Upgrade button
	if (currentLevel < maxLevel) {
		var upgradeBtn = LK.getAsset('weaponButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 0.8
		});
		upgradeBtn.x = 1400;
		upgradeBtn.y = yPos;
		upgradeBtn.tint = coins >= cost ? 0x00AA00 : 0x666666;
		game.addChild(upgradeBtn);
		storeElements.push(upgradeBtn);
		var btnText = new Text2('UPGRADE\n' + cost + ' coins', {
			size: 30,
			fill: 0xFFFFFF
		});
		btnText.anchor.set(0.5, 0.5);
		btnText.x = upgradeBtn.x;
		btnText.y = upgradeBtn.y;
		game.addChild(btnText);
		storeElements.push(btnText);
		if (coins >= cost) {
			upgradeBtn.down = function () {
				upgradeWeapon(weaponType);
			};
		}
	} else {
		var maxText = new Text2('MAX LEVEL', {
			size: 40,
			fill: 0xFFD700
		});
		maxText.anchor.set(0.5, 0.5);
		maxText.x = 1400;
		maxText.y = yPos;
		game.addChild(maxText);
		storeElements.push(maxText);
	}
}
function getUpgradeReduction(weaponType) {
	switch (weaponType) {
		case 'meteor':
			return 15;
		case 'bomb':
			return 25;
		case 'laser':
			return 20;
		case 'blackhole':
			return 40;
		case 'moon':
			return 50;
		default:
			return 15;
	}
}
function upgradeWeapon(weaponType) {
	var cost = upgradeCosts[weaponType][weaponUpgrades[weaponType]];
	if (coins >= cost && weaponUpgrades[weaponType] < 5) {
		coins -= cost;
		weaponUpgrades[weaponType]++;
		// Update storage immediately to persist the purchase
		storage.coins = coins;
		storage[weaponType + 'Upgrade'] = weaponUpgrades[weaponType];
		// Update cooldowns
		weaponCooldowns[weaponType] = Math.max(30, baseCooldowns[weaponType] - weaponUpgrades[weaponType] * getUpgradeReduction(weaponType));
		// Update coins display immediately
		coinsTxt.setText('Coins: ' + coins);
		// Refresh store display
		closeStore();
		openStore();
	}
}
function closeStore() {
	storeOpen = false;
	for (var i = 0; i < storeElements.length; i++) {
		storeElements[i].destroy();
	}
	storeElements = [];
	showMainMenu();
}
function hideMainMenu() {
	for (var i = 0; i < planetButtons.length; i++) {
		planetButtons[i].visible = false;
	}
	planetSelectTitle.visible = false;
	planetsTitle.visible = false;
	starsTitle.visible = false;
	startButton.visible = false;
	storeButton.visible = false;
}
function showMainMenu() {
	for (var i = 0; i < planetButtons.length; i++) {
		planetButtons[i].visible = true;
	}
	planetSelectTitle.visible = true;
	planetsTitle.visible = true;
	starsTitle.visible = true;
	startButton.visible = true;
	// Always show store button - players should be able to see upgrade options
	storeButton.visible = true;
}
function resetToLevelSelection() {
	// Reset game state
	gameStarted = false;
	planetDestroyed = false;
	// Clear all saved data to ensure fresh start on next game session
	storage.coins = 0;
	storage.level = 0;
	storage.meteorUpgrade = 0;
	storage.bombUpgrade = 0;
	storage.laserUpgrade = 0;
	storage.blackholeUpgrade = 0;
	storage.moonUpgrade = 0;
	storage.gameSaved = false;
	// Clean up game objects
	if (planet) {
		planet.destroy();
		planet = null;
	}
	// Clear arrays and destroy objects
	for (var i = meteors.length - 1; i >= 0; i--) {
		meteors[i].destroy();
	}
	meteors = [];
	for (var i = moons.length - 1; i >= 0; i--) {
		moons[i].destroy();
	}
	moons = [];
	for (var i = bombs.length - 1; i >= 0; i--) {
		bombs[i].destroy();
	}
	bombs = [];
	for (var i = explosions.length - 1; i >= 0; i--) {
		explosions[i].destroy();
	}
	explosions = [];
	// Close store if open
	if (storeOpen) {
		closeStore();
	}
	// Show planet selection UI again
	for (var i = 0; i < planetButtons.length; i++) {
		planetButtons[i].visible = true;
		// Update Jupiter unlock status
		if (planetButtons[i].planetType === 'jupiter') {
			if (level >= 10) {
				planetButtons[i].alpha = 1.0;
				planetButtons[i].interactive = true;
			} else {
				planetButtons[i].alpha = 0.3;
				planetButtons[i].interactive = false;
			}
		}
		// Update Sun unlock status
		if (planetButtons[i].planetType === 'sun') {
			if (level >= 50) {
				planetButtons[i].alpha = 1.0;
				planetButtons[i].interactive = true;
			} else {
				planetButtons[i].alpha = 0.3;
				planetButtons[i].interactive = false;
			}
		}
	}
	planetSelectTitle.visible = true;
	planetsTitle.visible = true;
	starsTitle.visible = true;
	startButton.visible = true;
	storeButton.visible = true;
	// Reset planet selection
	selectedPlanetType = 'earth';
	for (var i = 0; i < planetButtons.length; i++) {
		planetButtons[i].setSelected(false);
	}
	// Update UI displays with current values
	levelTxt.setText('Level: ' + level);
	coinsTxt.setText('Coins: ' + coins);
}
function isPlanetClick(x, y) {
	var distance = Math.sqrt(Math.pow(x - planet.x, 2) + Math.pow(y - planet.y, 2));
	return distance < 200;
}
function canUseWeapon(weaponType) {
	var timeSinceLastUse = gameTicks - lastWeaponUse[weaponType];
	return timeSinceLastUse >= weaponCooldowns[weaponType];
}
function useWeapon(weaponType) {
	lastWeaponUse[weaponType] = gameTicks;
}
game.down = function (x, y, obj) {
	if (!gameStarted || planetDestroyed) return;
	if (isPlanetClick(x, y)) {
		// Check if weapon is on cooldown
		if (!canUseWeapon(selectedWeapon)) {
			return; // Weapon is on cooldown, do nothing
		}
		switch (selectedWeapon) {
			case 'meteor':
				var meteor = new Meteor();
				meteor.x = Math.random() * 2048;
				meteor.y = -100;
				meteor.launch(x, y);
				meteors.push(meteor);
				game.addChild(meteor);
				useWeapon('meteor');
				break;
			case 'bomb':
				var bomb = new Bomb();
				bomb.x = x;
				bomb.y = y;
				bomb.activate();
				bombs.push(bomb);
				game.addChild(bomb);
				useWeapon('bomb');
				break;
			case 'laser':
				onLaserFire(x, 0, x, y);
				useWeapon('laser');
				break;
			case 'blackhole':
				onBlackholeActivate(x, y);
				useWeapon('blackhole');
				break;
			case 'moon':
				var moon = new Moon();
				moon.x = Math.random() * 2048;
				moon.y = -100;
				moon.launch(x, y);
				moons.push(moon);
				game.addChild(moon);
				useWeapon('moon');
				break;
		}
	}
};
game.update = function () {
	if (!gameStarted || planetDestroyed) return;
	// Increment game ticks for cooldown tracking
	gameTicks++;
	// Update meteors
	for (var i = meteors.length - 1; i >= 0; i--) {
		var meteor = meteors[i];
		if (!meteor.active) {
			meteor.destroy();
			meteors.splice(i, 1);
		}
	}
	// Update moons
	for (var i = moons.length - 1; i >= 0; i--) {
		var moon = moons[i];
		if (!moon.active) {
			moon.destroy();
			moons.splice(i, 1);
		}
	}
	// Update bombs
	for (var i = bombs.length - 1; i >= 0; i--) {
		var bomb = bombs[i];
		if (!bomb.active) {
			bomb.destroy();
			bombs.splice(i, 1);
		}
	}
	// Jupiter regeneration
	if (planet.planetType === 'jupiter' && planet.health > 0 && planet.health < planet.maxHealth) {
		jupiterRegenTimer++;
		if (jupiterRegenTimer >= jupiterRegenInterval) {
			jupiterRegenTimer = 0;
			// Reduce max health by 5 when regenerating
			planet.maxHealth -= 5;
			if (planet.maxHealth < 0) planet.maxHealth = 0;
			var regenAmount = planet.maxHealth * 0.05; // 5% of new max health
			var targetHealth = Math.min(planet.health + regenAmount, planet.maxHealth);
			// Use tween to smoothly animate health recovery
			tween(planet, {
				health: targetHealth
			}, {
				duration: 500,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Update planet appearance based on new health
					var healthPercent = planet.health / planet.maxHealth;
					var planetGraphics = planet.children[0]; // Get the planet graphics
					if (healthPercent > 0.7) {
						planetGraphics.tint = 0x4CAF50; // Green
					} else if (healthPercent > 0.4) {
						planetGraphics.tint = 0xFFEB3B; // Yellow
					} else {
						planetGraphics.tint = 0xFF5722; // Orange
					}
				}
			});
		}
	}
	// Update UI
	var healthPercent = Math.round(planet.health / planet.maxHealth * 100);
	var planetName = planet.planetType === 'earth' ? 'Earth' : planet.planetType.charAt(0).toUpperCase() + planet.planetType.slice(1);
	if (planet.planetType === 'jupiter') {
		healthTxt.setText(planetName + ': ' + Math.round(planet.health) + ' Health');
	} else {
		healthTxt.setText(planetName + ': ' + healthPercent + '% Health');
	}
	levelTxt.setText('Level: ' + level);
	coinsTxt.setText('Coins: ' + coins);
};

===================================================================
--- original.js
+++ change.js
@@ -357,27 +357,54 @@
 planetSelectTitle.anchor.set(0.5, 0.5);
 planetSelectTitle.x = 2048 / 2;
 planetSelectTitle.y = 400;
 game.addChild(planetSelectTitle);
+// Create planets section title
+var planetsTitle = new Text2('PLANETS', {
+	size: 60,
+	fill: 0xFFFFFF
+});
+planetsTitle.anchor.set(0.5, 0.5);
+planetsTitle.x = 2048 / 2;
+planetsTitle.y = 2732 / 2 - 200;
+game.addChild(planetsTitle);
 // Create planet selection buttons
-var planetTypes = ['earth', 'mercury', 'venus', 'mars', 'jupiter', 'sun'];
+var planetTypes = ['earth', 'mercury', 'venus', 'mars', 'jupiter'];
+var starTypes = ['sun'];
 for (var i = 0; i < planetTypes.length; i++) {
 	var planetButton = new PlanetButton(planetTypes[i]);
-	planetButton.x = 2048 / 2 + (i - 1.5) * 250;
-	planetButton.y = 2732 / 2;
+	planetButton.x = 2048 / 2 + (i - 2) * 200;
+	planetButton.y = 2732 / 2 - 100;
 	// Lock Jupiter if level is less than 10
 	if (planetTypes[i] === 'jupiter' && level < 10) {
 		planetButton.alpha = 0.3;
 		planetButton.interactive = false;
 	}
-	// Lock Sun if level is less than 50
-	if (planetTypes[i] === 'sun' && level < 50) {
-		planetButton.alpha = 0.3;
-		planetButton.interactive = false;
-	}
 	planetButtons.push(planetButton);
 	game.addChild(planetButton);
 }
+// Create stars section title
+var starsTitle = new Text2('STARS', {
+	size: 60,
+	fill: 0xFFD700
+});
+starsTitle.anchor.set(0.5, 0.5);
+starsTitle.x = 2048 / 2;
+starsTitle.y = 2732 / 2 + 50;
+game.addChild(starsTitle);
+// Create star selection buttons
+for (var i = 0; i < starTypes.length; i++) {
+	var starButton = new PlanetButton(starTypes[i]);
+	starButton.x = 2048 / 2 + (i - 0) * 200;
+	starButton.y = 2732 / 2 + 150;
+	// Lock Sun if level is less than 50
+	if (starTypes[i] === 'sun' && level < 50) {
+		starButton.alpha = 0.3;
+		starButton.interactive = false;
+	}
+	planetButtons.push(starButton);
+	game.addChild(starButton);
+}
 // Initial planet selection will be done by player
 // Initialize UI displays with stored values
 levelTxt.setText('Level: ' + level);
 coinsTxt.setText('Coins: ' + coins);
@@ -444,8 +471,10 @@
 		planetButtons[i].visible = false;
 	}
 	// Remove title and start button
 	planetSelectTitle.visible = false;
+	planetsTitle.visible = false;
+	starsTitle.visible = false;
 	startButton.visible = false;
 	// Hide store button during gameplay
 	storeButton.visible = false;
 	// Create selected planet
@@ -876,16 +905,20 @@
 	for (var i = 0; i < planetButtons.length; i++) {
 		planetButtons[i].visible = false;
 	}
 	planetSelectTitle.visible = false;
+	planetsTitle.visible = false;
+	starsTitle.visible = false;
 	startButton.visible = false;
 	storeButton.visible = false;
 }
 function showMainMenu() {
 	for (var i = 0; i < planetButtons.length; i++) {
 		planetButtons[i].visible = true;
 	}
 	planetSelectTitle.visible = true;
+	planetsTitle.visible = true;
+	starsTitle.visible = true;
 	startButton.visible = true;
 	// Always show store button - players should be able to see upgrade options
 	storeButton.visible = true;
 }
@@ -952,8 +985,10 @@
 			}
 		}
 	}
 	planetSelectTitle.visible = true;
+	planetsTitle.visible = true;
+	starsTitle.visible = true;
 	startButton.visible = true;
 	storeButton.visible = true;
 	// Reset planet selection
 	selectedPlanetType = 'earth';