/**** 
* 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 '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;
		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 = storage.level || 0;
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 = storage.coins || 0;
var storeOpen = false;
var storeElements = [];
// Weapon upgrade levels and costs
var weaponUpgrades = {
	meteor: storage.meteorUpgrade || 0,
	bomb: storage.bombUpgrade || 0,
	laser: storage.laserUpgrade || 0,
	blackhole: storage.blackholeUpgrade || 0,
	moon: storage.moonUpgrade || 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 planet selection buttons
var planetTypes = ['earth', 'venus', 'mars', 'jupiter'];
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;
	// 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);
}
// Initial planet selection will be done by player
// Initialize UI displays with stored values
levelTxt.setText('Level: ' + level);
coinsTxt.setText('Coins: ' + coins);
// Show main menu elements initially
showMainMenu();
// 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;
storeButton.visible = false; // Hide initially
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');
function selectPlanet(planetType) {
	// Check if Jupiter is locked
	if (planetType === 'jupiter' && level < 10) {
		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;
	startButton.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 = 3;
			level += 3;
		} else if (planet.planetType === 'venus') {
			levelsGained = 2;
			level += 2;
		} else if (planet.planetType === 'mars') {
			levelsGained = 1;
			level += 1;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 5;
			level += 5;
		}
		// Award coins: 100 per level gained
		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 = 3;
			level += 3;
		} else if (planet.planetType === 'venus') {
			levelsGained = 2;
			level += 2;
		} else if (planet.planetType === 'mars') {
			levelsGained = 1;
			level += 1;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 5;
			level += 5;
		}
		// Award coins: 100 per level gained
		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 = 3;
			level += 3;
		} else if (planet.planetType === 'venus') {
			levelsGained = 2;
			level += 2;
		} else if (planet.planetType === 'mars') {
			levelsGained = 1;
			level += 1;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 5;
			level += 5;
		}
		// Award coins: 100 per level gained
		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 = 3;
			level += 3;
		} else if (planet.planetType === 'venus') {
			levelsGained = 2;
			level += 2;
		} else if (planet.planetType === 'mars') {
			levelsGained = 1;
			level += 1;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 5;
			level += 5;
		}
		// Award coins: 100 per level gained
		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 = 3;
			level += 3;
		} else if (planet.planetType === 'venus') {
			levelsGained = 2;
			level += 2;
		} else if (planet.planetType === 'mars') {
			levelsGained = 1;
			level += 1;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 5;
			level += 5;
		}
		// Award coins: 100 per level gained
		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]++;
		storage.coins = coins;
		storage[weaponType + 'Upgrade'] = weaponUpgrades[weaponType];
		// Update cooldowns
		weaponCooldowns[weaponType] = Math.max(30, baseCooldowns[weaponType] - weaponUpgrades[weaponType] * getUpgradeReduction(weaponType));
		// 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;
	startButton.visible = false;
	storeButton.visible = false;
}
function showMainMenu() {
	for (var i = 0; i < planetButtons.length; i++) {
		planetButtons[i].visible = true;
	}
	planetSelectTitle.visible = true;
	startButton.visible = true;
	storeButton.visible = true;
}
function resetToLevelSelection() {
	// Reset game state
	gameStarted = false;
	planetDestroyed = 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;
			}
		}
	}
	planetSelectTitle.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
@@ -364,8 +364,13 @@
 	planetButtons.push(planetButton);
 	game.addChild(planetButton);
 }
 // Initial planet selection will be done by player
+// Initialize UI displays with stored values
+levelTxt.setText('Level: ' + level);
+coinsTxt.setText('Coins: ' + coins);
+// Show main menu elements initially
+showMainMenu();
 // Create start game button
 var startButton = new Text2('START GAME', {
 	size: 60,
 	fill: 0x00FF00
@@ -386,8 +391,9 @@
 });
 storeButton.anchor.set(0.5, 0.5);
 storeButton.x = 2048 / 2 + 200;
 storeButton.y = 2732 / 2 + 200;
+storeButton.visible = false; // Hide initially
 game.addChild(storeButton);
 storeButton.down = function (x, y, obj) {
 	if (!gameStarted) {
 		openStore();