/**** 
* 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 FireORB = Container.expand(function () {
	var self = Container.call(this);
	var fireorbGraphics = self.attachAsset('fireorb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.targetX = 0;
	self.targetY = 0;
	self.speed = 7;
	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 < 35) {
			self.active = false;
			onFireORBHit(self.x, self.y);
		}
	};
	return self;
});
var Ganymede = Container.expand(function () {
	var self = Container.call(this);
	var ganymedeGraphics = self.attachAsset('ganymede', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.targetX = 0;
	self.targetY = 0;
	self.speed = 4;
	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 < 50) {
			self.active = false;
			onGanymedeHit(self.x, self.y);
		}
	};
	return self;
});
var IceExplosion = Container.expand(function () {
	var self = Container.call(this);
	var explosionGraphics = self.attachAsset('iceExplosion', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	explosionGraphics.tint = 0x00FFFF; // Ice blue tint
	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 'uranus':
			self.health = 270;
			self.maxHealth = 270;
			self.uranusFirstAttackTaken = false;
			break;
		case 'saturn':
			self.health = 300;
			self.maxHealth = 300;
			self.saturnPowerActivated = false;
			break;
		case 'sun':
			self.health = 10000;
			self.maxHealth = 10000;
			break;
		default:
			self.health = 100;
			self.maxHealth = 100;
			break;
	}
	self.destructionZones = [];
	self.takeDamage = function (amount, x, y) {
		// Uranus special power: 25% less damage on first attack (excluding meteors)
		if (self.planetType === 'uranus' && !self.uranusFirstAttackTaken) {
			self.uranusFirstAttackTaken = true;
			amount = amount * 0.75; // 25% damage reduction
		}
		self.health -= amount;
		// Saturn special power: increase health to 180 when reaching 150 health
		if (self.planetType === 'saturn' && !self.saturnPowerActivated && self.health <= 150 && self.health > 0) {
			self.saturnPowerActivated = true;
			var healthIncrease = 180 - self.health;
			self.health = 180;
			self.maxHealth += healthIncrease;
		}
		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;
		case 'ganymede':
			iconAsset = 'ganymede';
			break;
		case 'iceLaser':
			iconAsset = 'iceLaser';
			break;
		case 'fireorb':
			iconAsset = 'fireorb';
			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 ganymedes = [];
var fireorbs = [];
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
	iceLaser: 210,
	// 3.5 seconds (2.5 + 1)
	blackhole: 300,
	// 5 seconds
	moon: 420,
	// 7 seconds
	ganymede: 900,
	// 15 seconds
	fireorb: 180 // 3 seconds
};
var lastWeaponUse = {
	meteor: -999,
	bomb: -999,
	laser: -999,
	iceLaser: -999,
	blackhole: -999,
	moon: -999,
	ganymede: -999,
	fireorb: -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,
	iceLaser: 0,
	blackhole: 0,
	moon: 0,
	ganymede: 0,
	fireorb: 0
};
// Ice laser freeze timer variables
var iceLaserUseCount = 0;
var maxIceLaserUses = 4;
// 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],
	iceLaser: [125, 250, 375, 625, 1000],
	blackhole: [250, 500, 750, 1250, 2000],
	moon: [300, 600, 900, 1500, 2400],
	ganymede: [500, 1000, 1500, 2500, 4000],
	fireorb: [150, 300, 450, 750, 1200]
};
// 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),
	iceLaser: Math.max(50, baseCooldowns.iceLaser - weaponUpgrades.iceLaser * 20),
	blackhole: Math.max(90, baseCooldowns.blackhole - weaponUpgrades.blackhole * 40),
	moon: Math.max(120, baseCooldowns.moon - weaponUpgrades.moon * 50),
	ganymede: Math.max(300, baseCooldowns.ganymede - weaponUpgrades.ganymede * 100),
	fireorb: Math.max(45, baseCooldowns.fireorb - weaponUpgrades.fireorb * 25)
};
// 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);
// Freeze timer display
var freezeTimerTxt = new Text2('Freeze: 0/4', {
	size: 50,
	fill: 0x00FFFF
});
freezeTimerTxt.anchor.set(0.5, 0);
freezeTimerTxt.y = 210;
freezeTimerTxt.visible = false; // Only show when ice laser is selected
LK.gui.top.addChild(freezeTimerTxt);
// 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', 'uranus', 'jupiter', 'saturn'];
var starTypes = ['sun'];
for (var i = 0; i < planetTypes.length; i++) {
	var planetButton = new PlanetButton(planetTypes[i]);
	planetButton.x = 2048 / 2 + (i - 3) * 200;
	planetButton.y = 2732 / 2 - 100;
	// Add level reward text for Uranus
	if (planetTypes[i] === 'uranus') {
		var uranusRewardText = new Text2('20 levels', {
			size: 25,
			fill: 0xFFD700
		});
		uranusRewardText.anchor.set(0.5, 0);
		uranusRewardText.y = 120;
		planetButton.addChild(uranusRewardText);
	}
	// Add level reward text for Jupiter
	if (planetTypes[i] === 'jupiter') {
		var jupiterRewardText = new Text2('10 levels', {
			size: 25,
			fill: 0xFFD700
		});
		jupiterRewardText.anchor.set(0.5, 0);
		jupiterRewardText.y = 120;
		planetButton.addChild(jupiterRewardText);
	}
	// Add level reward text for Saturn
	if (planetTypes[i] === 'saturn') {
		var saturnRewardText = new Text2('15 levels', {
			size: 25,
			fill: 0xFFD700
		});
		saturnRewardText.anchor.set(0.5, 0);
		saturnRewardText.y = 120;
		planetButton.addChild(saturnRewardText);
	}
	// Lock Uranus if level is less than 20
	if (planetTypes[i] === 'uranus' && level < 20) {
		planetButton.alpha = 0.3;
		planetButton.interactive = false;
	}
	// Lock Jupiter if level is less than 10
	if (planetTypes[i] === 'jupiter' && level < 10) {
		planetButton.alpha = 0.3;
		planetButton.interactive = false;
	}
	// Lock Saturn if level is less than 15
	if (planetTypes[i] === 'saturn' && level < 15) {
		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;
	// Add level reward text for Sun
	if (starTypes[i] === 'sun') {
		var sunRewardText = new Text2('50 levels', {
			size: 30,
			fill: 0xFFD700
		});
		sunRewardText.anchor.set(0.5, 0);
		sunRewardText.y = 120;
		starButton.addChild(sunRewardText);
	}
	// 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;
startButton.y = 2732 / 2 + 350;
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;
storeButton.y = 2732 / 2 + 450;
game.addChild(storeButton);
storeButton.down = function (x, y, obj) {
	if (!gameStarted) {
		openStore();
	}
};
// Create weapon selection buttons
var weaponTypes = ['meteor', 'bomb', 'laser', 'iceLaser', 'blackhole', 'fireorb', 'moon', 'ganymede'];
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);
}
// Create exit button
var exitButton = new Text2('EXIT', {
	size: 50,
	fill: 0xFF5555
});
exitButton.anchor.set(0.5, 0.5);
exitButton.x = 2048 - 100;
exitButton.y = 2732 - 150;
exitButton.visible = false; // Hidden initially
game.addChild(exitButton);
exitButton.down = function (x, y, obj) {
	if (gameStarted && !planetDestroyed) {
		resetToLevelSelection();
	}
};
// Select initial weapon
selectWeapon('meteor');
// Load saved weapon upgrades from storage
weaponUpgrades.meteor = storage.meteorUpgrade || 0;
weaponUpgrades.bomb = storage.bombUpgrade || 0;
weaponUpgrades.laser = storage.laserUpgrade || 0;
weaponUpgrades.iceLaser = storage.iceLaserUpgrade || 0;
weaponUpgrades.blackhole = storage.blackholeUpgrade || 0;
weaponUpgrades.moon = storage.moonUpgrade || 0;
weaponUpgrades.ganymedes = storage.ganymedeUpgrade || 0;
weaponUpgrades.fireorb = storage.fireorbUpgrade || 0;
// Load saved coins and level
coins = storage.coins || 0;
level = storage.level || 0;
// Recalculate weapon cooldowns based on loaded upgrades
weaponCooldowns.meteor = Math.max(30, baseCooldowns.meteor - weaponUpgrades.meteor * 15);
weaponCooldowns.bomb = Math.max(45, baseCooldowns.bomb - weaponUpgrades.bomb * 25);
weaponCooldowns.laser = Math.max(30, baseCooldowns.laser - weaponUpgrades.laser * 20);
weaponCooldowns.iceLaser = Math.max(50, baseCooldowns.iceLaser - weaponUpgrades.iceLaser * 20);
weaponCooldowns.blackhole = Math.max(90, baseCooldowns.blackhole - weaponUpgrades.blackhole * 40);
weaponCooldowns.moon = Math.max(120, baseCooldowns.moon - weaponUpgrades.moon * 50);
weaponCooldowns.ganymede = Math.max(300, baseCooldowns.ganymede - weaponUpgrades.ganymede * 100);
weaponCooldowns.fireorb = Math.max(45, baseCooldowns.fireorb - weaponUpgrades.fireorb * 25);
// 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 Uranus is locked
	if (planetType === 'uranus' && level < 20) {
		return; // Don't select if locked
	}
	// Check if Jupiter is locked
	if (planetType === 'jupiter' && level < 10) {
		return; // Don't select if locked
	}
	// Check if Saturn is locked
	if (planetType === 'saturn' && level < 15) {
		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;
	// Show exit button during gameplay
	exitButton.visible = true;
	// 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);
	}
	// Show/hide freeze timer based on weapon selection
	freezeTimerTxt.visible = weaponType === 'iceLaser';
	if (weaponType === 'iceLaser') {
		freezeTimerTxt.setText('Freeze: ' + iceLaserUseCount + '/' + maxIceLaserUses);
	}
}
function onMeteorHit(x, y) {
	LK.getSound('meteorHit').play();
	var damage = 15;
	var destroyed = planet.takeDamage(damage, 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 === 'uranus') {
			levelsGained = 9;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 12;
		} else if (planet.planetType === 'saturn') {
			levelsGained = 7;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (100) with this gain
		var maxLevel = 100;
		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 += 10000; // 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 damage = 50;
	var destroyed = planet.takeDamage(damage, 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 === 'uranus') {
			levelsGained = 9;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 12;
		} else if (planet.planetType === 'saturn') {
			levelsGained = 7;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (100) with this gain
		var maxLevel = 100;
		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 += 10000; // 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 damage = 25;
	var destroyed = planet.takeDamage(damage, 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 === 'uranus') {
			levelsGained = 9;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 12;
		} else if (planet.planetType === 'saturn') {
			levelsGained = 7;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (100) with this gain
		var maxLevel = 100;
		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 += 10000; // 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 damage = 20;
	// Uranus special power: laser damage is halved on first attack
	if (planet.planetType === 'uranus' && !planet.uranusFirstAttackTaken) {
		damage = damage / 2; // Divide by 2 for first laser attack
	}
	var destroyed = planet.takeDamage(damage, 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 === 'uranus') {
			levelsGained = 9;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 12;
		} else if (planet.planetType === 'saturn') {
			levelsGained = 7;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (100) with this gain
		var maxLevel = 100;
		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 += 10000; // 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 onIceLaserFire(startX, startY, endX, endY) {
	LK.getSound('iceLaserFire').play();
	// Increment ice laser use count
	iceLaserUseCount++;
	// Calculate damage - base 20 + 20 bonus if freeze timer is full
	var damage = 20;
	var isFrozen = iceLaserUseCount >= maxIceLaserUses;
	if (isFrozen) {
		damage += 20; // Extra damage when frozen
		// Reset freeze timer
		iceLaserUseCount = 0;
		// Visual effect for frozen state
		tween(planet, {
			tint: 0x00FFFF
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(planet, {
					tint: 0xFFFFFF
				}, {
					duration: 300,
					easing: tween.easeIn
				});
			}
		});
	}
	// Update freeze timer display
	freezeTimerTxt.setText('Freeze: ' + iceLaserUseCount + '/' + maxIceLaserUses);
	var destroyed = planet.takeDamage(damage, endX, endY);
	createExplosion(endX, endY);
	// Add ice effect to explosion
	if (isFrozen) {
		// Create additional ice-colored explosion using IceExplosion class
		var iceExplosion = new IceExplosion();
		iceExplosion.x = endX;
		iceExplosion.y = endY;
		explosions.push(iceExplosion);
		game.addChild(iceExplosion);
	} else {
		// Create regular ice explosion for all ice laser hits
		var iceExplosion = new IceExplosion();
		iceExplosion.x = endX;
		iceExplosion.y = endY;
		explosions.push(iceExplosion);
		game.addChild(iceExplosion);
	}
	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 === 'uranus') {
			levelsGained = 9;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 12;
		} else if (planet.planetType === 'saturn') {
			levelsGained = 7;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (100) with this gain
		var maxLevel = 100;
		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 += 10000; // 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 onGanymedeHit(x, y) {
	LK.getSound('moonHit').play();
	var damage = 100;
	var destroyed = planet.takeDamage(damage, 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 === 'uranus') {
			levelsGained = 9;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 12;
		} else if (planet.planetType === 'saturn') {
			levelsGained = 7;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (100) with this gain
		var maxLevel = 100;
		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 += 10000; // 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 damage = 30;
	var destroyed = planet.takeDamage(damage, 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 === 'uranus') {
			levelsGained = 9;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 12;
		} else if (planet.planetType === 'saturn') {
			levelsGained = 7;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (100) with this gain
		var maxLevel = 100;
		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 += 10000; // 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 onFireORBHit(x, y) {
	LK.getSound('meteorHit').play();
	var baseDamage = 30;
	// 50% chance to add 10 extra damage
	var extraDamage = Math.random() < 0.5 ? 10 : 0;
	var damage = baseDamage + extraDamage;
	var destroyed = planet.takeDamage(damage, 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 === 'uranus') {
			levelsGained = 9;
		} else if (planet.planetType === 'jupiter') {
			levelsGained = 12;
		} else if (planet.planetType === 'saturn') {
			levelsGained = 7;
		} else if (planet.planetType === 'sun') {
			levelsGained = 50;
		}
		// Check if player reaches max level (100) with this gain
		var maxLevel = 100;
		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 += 10000; // 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', 'iceLaser', 'blackhole', 'fireorb', 'moon', 'ganymede'];
	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) {
	// Determine if this weapon should be on the left or right side
	var isRightSide = weaponType === 'meteor' || weaponType === 'bomb' || weaponType === 'laser' || weaponType === 'iceLaser' || weaponType === 'blackhole';
	var isLeftSide = weaponType === 'fireorb' || weaponType === 'moon' || weaponType === 'ganymede';
	// Calculate position based on side and index within that side
	var sideIndex;
	var yPos;
	if (isRightSide) {
		var rightWeapons = ['meteor', 'bomb', 'laser', 'iceLaser', 'blackhole'];
		sideIndex = rightWeapons.indexOf(weaponType);
		yPos = 500 + sideIndex * 200;
	} else {
		var leftWeapons = ['fireorb', 'moon', 'ganymede'];
		sideIndex = leftWeapons.indexOf(weaponType);
		yPos = 500 + sideIndex * 200;
	}
	var currentLevel = weaponUpgrades[weaponType];
	var maxLevel = 5;
	var cost = currentLevel < maxLevel ? upgradeCosts[weaponType][currentLevel] : 0;
	// Position elements based on side
	var iconX = isRightSide ? 1400 : 400;
	var textX = isRightSide ? 1250 : 550;
	var upgradeX = isRightSide ? 800 : 1400;
	// Weapon icon
	var icon = LK.getAsset(weaponType, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8
	});
	icon.x = iconX;
	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(isRightSide ? 1 : 0, 0.5);
	nameText.x = textX;
	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(isRightSide ? 1 : 0, 0.5);
	cooldownText.x = textX;
	cooldownText.y = yPos + 30;
	game.addChild(cooldownText);
	storeElements.push(cooldownText);
	// Weapon description
	var description = '';
	switch (weaponType) {
		case 'meteor':
			description = 'I am the simplest';
			break;
		case 'bomb':
			description = 'Explode the planet like a bomb';
			break;
		case 'laser':
			description = 'I am better than my brother';
			break;
		case 'iceLaser':
			description = 'are you sure laser, I am better than you.';
			break;
		case 'blackhole':
			description = 'why am I so powerless?';
			break;
		case 'moon':
			description = 'The world created me, but I will destroy it.';
			break;
		case 'ganymede':
			description = 'IM THE BEST!';
			break;
		case 'fireorb':
			description = '50% chance for extra damage';
			break;
	}
	var descriptionText = new Text2(description, {
		size: 30,
		fill: 0xFFAA00
	});
	descriptionText.anchor.set(isRightSide ? 1 : 0, 0.5);
	descriptionText.x = textX;
	descriptionText.y = yPos + 70;
	game.addChild(descriptionText);
	storeElements.push(descriptionText);
	// Upgrade button
	if (currentLevel < maxLevel) {
		var upgradeBtn = LK.getAsset('weaponButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 0.8
		});
		upgradeBtn.x = upgradeX;
		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 = upgradeX;
		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 'iceLaser':
			return 20;
		case 'blackhole':
			return 40;
		case 'moon':
			return 50;
		case 'ganymede':
			return 100;
		case 'fireorb':
			return 25;
		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
		var minCooldown = weaponType === 'iceLaser' ? 50 : 30;
		var minCooldown = weaponType === 'iceLaser' ? 50 : weaponType === 'fireorb' ? 45 : 30;
		weaponCooldowns[weaponType] = Math.max(minCooldown, 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.iceLaserUpgrade = 0;
	storage.blackholeUpgrade = 0;
	storage.moonUpgrade = 0;
	storage.ganymedeUpgrade = 0;
	storage.fireorbUpgrade = 0;
	storage.gameSaved = false;
	// Reset ice laser freeze timer
	iceLaserUseCount = 0;
	// 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 = ganymedes.length - 1; i >= 0; i--) {
		ganymedes[i].destroy();
	}
	ganymedes = [];
	for (var i = fireorbs.length - 1; i >= 0; i--) {
		fireorbs[i].destroy();
	}
	fireorbs = [];
	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 Uranus unlock status
		if (planetButtons[i].planetType === 'uranus') {
			if (level >= 20) {
				planetButtons[i].alpha = 1.0;
				planetButtons[i].interactive = true;
			} else {
				planetButtons[i].alpha = 0.3;
				planetButtons[i].interactive = false;
			}
		}
		// 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 Saturn unlock status
		if (planetButtons[i].planetType === 'saturn') {
			if (level >= 15) {
				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;
	// Hide exit button when returning to menu
	exitButton.visible = false;
	// Reset planet selection
	selectedPlanetType = 'earth';
	for (var i = 0; i < planetButtons.length; i++) {
		planetButtons[i].setSelected(false);
	}
	// Update UI displays with current values
	if (level >= 100) {
		levelTxt.setText('Level: ' + level + ' (max level)');
	} else {
		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 'iceLaser':
				onIceLaserFire(x, 0, x, y);
				useWeapon('iceLaser');
				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;
			case 'ganymede':
				var ganymede = new Ganymede();
				ganymede.x = Math.random() * 2048;
				ganymede.y = -100;
				ganymede.launch(x, y);
				ganymedes.push(ganymede);
				game.addChild(ganymede);
				useWeapon('ganymede');
				break;
			case 'fireorb':
				var fireorb = new FireORB();
				fireorb.x = Math.random() * 2048;
				fireorb.y = -100;
				fireorb.launch(x, y);
				fireorbs.push(fireorb);
				game.addChild(fireorb);
				useWeapon('fireorb');
				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 ganymedes
	for (var i = ganymedes.length - 1; i >= 0; i--) {
		var ganymede = ganymedes[i];
		if (!ganymede.active) {
			ganymede.destroy();
			ganymedes.splice(i, 1);
		}
	}
	// Update fireorbs
	for (var i = fireorbs.length - 1; i >= 0; i--) {
		var fireorb = fireorbs[i];
		if (!fireorb.active) {
			fireorb.destroy();
			fireorbs.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 if (planet.planetType === 'saturn') {
		healthTxt.setText(planetName + ': ' + Math.round(planet.health) + ' Health');
	} else if (planet.planetType === 'uranus') {
		healthTxt.setText(planetName + ': ' + Math.round(planet.health) + ' Health');
	} else if (planet.planetType === 'sun') {
		healthTxt.setText(planetName + ': ' + Math.round(planet.health) + ' Health');
	} else {
		healthTxt.setText(planetName + ': ' + healthPercent + '% Health');
	}
	if (level >= 100) {
		levelTxt.setText('Level: ' + level + ' (max level)');
	} else {
		levelTxt.setText('Level: ' + level);
	}
	coinsTxt.setText('Coins: ' + coins);
};

===================================================================
--- original.js
+++ change.js
@@ -1257,20 +1257,38 @@
 		closeStore();
 	};
 }
 function createUpgradeButton(weaponType, index) {
-	var yPos = 600 + index * 300;
+	// Determine if this weapon should be on the left or right side
+	var isRightSide = weaponType === 'meteor' || weaponType === 'bomb' || weaponType === 'laser' || weaponType === 'iceLaser' || weaponType === 'blackhole';
+	var isLeftSide = weaponType === 'fireorb' || weaponType === 'moon' || weaponType === 'ganymede';
+	// Calculate position based on side and index within that side
+	var sideIndex;
+	var yPos;
+	if (isRightSide) {
+		var rightWeapons = ['meteor', 'bomb', 'laser', 'iceLaser', 'blackhole'];
+		sideIndex = rightWeapons.indexOf(weaponType);
+		yPos = 500 + sideIndex * 200;
+	} else {
+		var leftWeapons = ['fireorb', 'moon', 'ganymede'];
+		sideIndex = leftWeapons.indexOf(weaponType);
+		yPos = 500 + sideIndex * 200;
+	}
 	var currentLevel = weaponUpgrades[weaponType];
 	var maxLevel = 5;
 	var cost = currentLevel < maxLevel ? upgradeCosts[weaponType][currentLevel] : 0;
+	// Position elements based on side
+	var iconX = isRightSide ? 1400 : 400;
+	var textX = isRightSide ? 1250 : 550;
+	var upgradeX = isRightSide ? 800 : 1400;
 	// Weapon icon
 	var icon = LK.getAsset(weaponType, {
 		anchorX: 0.5,
 		anchorY: 0.5,
 		scaleX: 0.8,
 		scaleY: 0.8
 	});
-	icon.x = 400;
+	icon.x = iconX;
 	icon.y = yPos;
 	game.addChild(icon);
 	storeElements.push(icon);
 	// Weapon name and level
@@ -1278,10 +1296,10 @@
 	var nameText = new Text2(weaponName + ' (Level ' + currentLevel + '/' + maxLevel + ')', {
 		size: 50,
 		fill: 0xFFFFFF
 	});
-	nameText.anchor.set(0, 0.5);
-	nameText.x = 550;
+	nameText.anchor.set(isRightSide ? 1 : 0, 0.5);
+	nameText.x = textX;
 	nameText.y = yPos - 30;
 	game.addChild(nameText);
 	storeElements.push(nameText);
 	// Cooldown info
@@ -1290,10 +1308,10 @@
 	var cooldownText = new Text2('Cooldown: ' + (currentCooldown / 60).toFixed(1) + 's', {
 		size: 40,
 		fill: 0xCCCCCC
 	});
-	cooldownText.anchor.set(0, 0.5);
-	cooldownText.x = 550;
+	cooldownText.anchor.set(isRightSide ? 1 : 0, 0.5);
+	cooldownText.x = textX;
 	cooldownText.y = yPos + 30;
 	game.addChild(cooldownText);
 	storeElements.push(cooldownText);
 	// Weapon description
@@ -1327,10 +1345,10 @@
 	var descriptionText = new Text2(description, {
 		size: 30,
 		fill: 0xFFAA00
 	});
-	descriptionText.anchor.set(0, 0.5);
-	descriptionText.x = 550;
+	descriptionText.anchor.set(isRightSide ? 1 : 0, 0.5);
+	descriptionText.x = textX;
 	descriptionText.y = yPos + 70;
 	game.addChild(descriptionText);
 	storeElements.push(descriptionText);
 	// Upgrade button
@@ -1340,9 +1358,9 @@
 			anchorY: 0.5,
 			scaleX: 1.2,
 			scaleY: 0.8
 		});
-		upgradeBtn.x = 1400;
+		upgradeBtn.x = upgradeX;
 		upgradeBtn.y = yPos;
 		upgradeBtn.tint = coins >= cost ? 0x00AA00 : 0x666666;
 		game.addChild(upgradeBtn);
 		storeElements.push(upgradeBtn);
@@ -1365,9 +1383,9 @@
 			size: 40,
 			fill: 0xFFD700
 		});
 		maxText.anchor.set(0.5, 0.5);
-		maxText.x = 1400;
+		maxText.x = upgradeX;
 		maxText.y = yPos;
 		game.addChild(maxText);
 		storeElements.push(maxText);
 	}