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

/**** 
* Classes
****/ 
var Asteroid = Container.expand(function () {
	var self = Container.call(this);
	var asteroidGraphics = self.attachAsset('asteroid', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Randomize asteroid size between 45x45 and 70x70
	// Base asset is 60x60, so scale range is 0.75 to 1.17
	var randomScale = 0.75 + Math.random() * 0.42; // Random value between 0.75 and 1.17
	asteroidGraphics.scaleX = randomScale;
	asteroidGraphics.scaleY = randomScale;
	self.velocityX = 0;
	self.velocityY = 0;
	self.targetPlanet = null;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		asteroidGraphics.rotation += 0.05;
	};
	return self;
});
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
	};
	return self;
});
var Laser = Container.expand(function () {
	var self = Container.call(this);
	var laserGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	laserGraphics.tint = 0x00ff00; // Green laser color
	laserGraphics.scaleX = 0.5; // Make laser thinner
	laserGraphics.scaleY = 2; // Make laser longer
	self.velocityX = 0;
	self.velocityY = 0;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
	};
	return self;
});
var OrbitLine = Container.expand(function (radius) {
	var self = Container.call(this);
	self.orbitRadius = radius;
	// Create a single connected circular line using small line segments
	var numSegments = Math.max(16, Math.floor(radius * 0.1)); // Fewer segments for better performance
	var twoPi = Math.PI * 2; // Cache the calculation
	for (var i = 0; i < numSegments; i++) {
		var angle1 = i / numSegments * twoPi;
		var angle2 = (i + 1) / numSegments * twoPi;
		var x1 = Math.cos(angle1) * radius;
		var y1 = Math.sin(angle1) * radius;
		var x2 = Math.cos(angle2) * radius;
		var y2 = Math.sin(angle2) * radius;
		// Calculate segment length and angle
		var segmentLength = Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
		var segmentAngle = Math.atan2(y2 - y1, x2 - x1);
		// Create line segment
		var lineSegment = self.attachAsset('orbitLine', {
			anchorX: 0,
			anchorY: 0.5,
			alpha: 0.4,
			scaleX: segmentLength / 2,
			// Scale to match segment length
			scaleY: 1
		});
		// Position and rotate the segment
		lineSegment.x = x1;
		lineSegment.y = y1;
		lineSegment.rotation = segmentAngle;
	}
	return self;
});
var Planet = Container.expand(function (size, color, orbitRadius, orbitSpeed) {
	var self = Container.call(this);
	self.orbitRadius = orbitRadius;
	self.orbitSpeed = orbitSpeed;
	self.angle = Math.random() * Math.PI * 2;
	var assetName = 'mercury';
	if (color === 0x4169e1) {
		assetName = 'earth';
	} else if (color === 0xff4500) {
		assetName = 'mars';
	} else if (color === 0xffc649) {
		assetName = 'venus';
	} else if (color === 0xd2691e) {
		assetName = 'jupiter';
	} else if (color === 0xffd700) {
		assetName = 'saturn';
	} else if (color === 0x40e0d0) {
		assetName = 'uranus';
	} else if (color === 0x0080ff) {
		assetName = 'neptune';
	}
	var planetGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.angle += self.orbitSpeed;
		var cosAngle = Math.cos(self.angle);
		var sinAngle = Math.sin(self.angle);
		self.x = sunX + cosAngle * self.orbitRadius;
		self.y = sunY + sinAngle * self.orbitRadius;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Show instructions before game starts
var instructionText = new Text2(" How to play:\n\nGoal:\n- protect the Earth from asteroid collisions\n- you will be given a spaceship that shoots lasers\n- you will use these lasers to destroy asteroids\n- if the Earth gets hit with 4 asteroids, you lose\n- if you have multiple spaceships, they will all fire where you choose\n\nPoints:\n- every asteroid you destroy will earn you five points\n- every 50 points, you will recieve a new spaceship you can put in the solar system\n- if you reach 200 points, that interval will increase to every 100 points\n- with a price of 75 points, you can buy a laser upgrade that randomly applies to one ship in play, giving it the ability to shoot two lasers instead of one\n\nAsteroids:\n- asteroids are your enimies\n- they can be destroyed with one laser hit\n- they will come from random directions, so be aware of all sides of the screen\n- planets are you friends, all planets other than Earth deflect asteroids\n- if a ship gets hit with an asteroid, it will be removed, so keep a lookout for your ships\n\nControls:\n- select a spaceship until it shrinks, then click and drag it to move it, release to place it\n- click any point on the sreen to fire lasers in that direction\n- if you have multiple spaceships, they will all fire where you choose", {
	size: 60,
	fill: 0xFFFFFF,
	wordWrap: true,
	wordWrapWidth: 1600
});
instructionText.anchor.set(0.5, 0.5);
instructionText.x = 2048 / 2;
instructionText.y = 2732 / 2 - 100;
game.addChild(instructionText);
// Add separate "Got it!" button text
var gotItText = new Text2("Got it!", {
	size: 80,
	fill: 0xFFFFFF
});
gotItText.anchor.set(0.5, 0.5);
gotItText.x = 2048 / 2;
gotItText.y = 2732 - 200; // Position below instructions, above bottom of screen
game.addChild(gotItText);
// Add spinning earth to top right corner of instructions
var instructionEarth = LK.getAsset('earth', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 3,
	scaleY: 3,
	x: 2048 - 200,
	y: 200
});
game.addChild(instructionEarth);
// Add defensive ship next to spinning earth
var instructionShip = LK.getAsset('defensiveShip', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 1.5,
	scaleY: 1.5,
	x: 2048 - 450,
	y: 200
});
game.addChild(instructionShip);
// Start spinning animation
function spinEarth() {
	tween(instructionEarth, {
		rotation: instructionEarth.rotation + Math.PI * 2
	}, {
		duration: 3000,
		easing: tween.linear,
		onFinish: function onFinish() {
			if (instructionsVisible) {
				spinEarth();
			}
		}
	});
}
spinEarth();
// Add click handler to dismiss instructions
var instructionsVisible = true;
var instructionAsteroids = [];
var instructionAsteroidSpawnTimer = 0;
game.down = function (x, y, obj) {
	if (instructionsVisible) {
		// Check if "Got it!" button was clicked
		var gotItClickArea = {
			x: gotItText.x - gotItText.width / 2 - 50,
			y: gotItText.y - gotItText.height / 2 - 25,
			width: gotItText.width + 100,
			height: gotItText.height + 50
		};
		if (x >= gotItClickArea.x && x <= gotItClickArea.x + gotItClickArea.width && y >= gotItClickArea.y && y <= gotItClickArea.y + gotItClickArea.height) {
			// Hide instructions and start the game
			instructionText.destroy();
			gotItText.destroy();
			instructionEarth.destroy();
			instructionShip.destroy();
			// Clean up instruction asteroids
			for (var i = 0; i < instructionAsteroids.length; i++) {
				instructionAsteroids[i].destroy();
			}
			instructionAsteroids = [];
			instructionsVisible = false;
			// Initialize all game assets now
			initializeGameAssets();
			// Re-define the game.down handler for normal gameplay
		}
		return;
	}
	// Check if any improve lasers text was clicked
	for (var k = 0; k < defensiveShips.length; k++) {
		var ship = defensiveShips[k];
		if (ship.visible && ship.improveLasersText.visible) {
			// Convert coordinates to check if improve lasers text was clicked
			var improveLasersClickArea = {
				x: ship.improveLasersText.x - ship.improveLasersText.width,
				y: ship.improveLasersText.y - ship.improveLasersText.height / 2,
				width: ship.improveLasersText.width,
				height: ship.improveLasersText.height
			};
			// Convert click coordinates to GUI space
			var guiPos = LK.gui.topRight.toLocal(game.toGlobal({
				x: x,
				y: y
			}));
			if (guiPos.x >= improveLasersClickArea.x && guiPos.x <= improveLasersClickArea.x + improveLasersClickArea.width && guiPos.y >= improveLasersClickArea.y && guiPos.y <= improveLasersClickArea.y + improveLasersClickArea.height) {
				// Check if player has enough points to use improve lasers
				if (LK.getScore() < 75) {
					return; // Not enough points, don't process the upgrade
				}
				// Find all placed ships that don't already have improved lasers
				var upgradeableShips = [];
				for (var j = 0; j < defensiveShips.length; j++) {
					if (defensiveShips[j].placed && !defensiveShips[j].hasImprovedLasers) {
						upgradeableShips.push(defensiveShips[j]);
					}
				}
				// Randomly select one ship to upgrade
				if (upgradeableShips.length > 0) {
					// Deduct 75 points from score
					LK.setScore(LK.getScore() - 75);
					scoreTxt.setText('Score: ' + LK.getScore());
					var randomIndex = Math.floor(Math.random() * upgradeableShips.length);
					var selectedShip = upgradeableShips[randomIndex];
					selectedShip.hasImprovedLasers = true;
					// Visual feedback - flash the upgraded ship
					tween(selectedShip, {
						tint: 0x00ff00
					}, {
						duration: 500,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							tween(selectedShip, {
								tint: 0xffffff
							}, {
								duration: 500,
								easing: tween.easeOut
							});
						}
					});
				}
				return; // Don't fire lasers when clicking improve lasers
			}
		}
	}
	// Check if laser firing is on cooldown
	if (laserCooldownActive) {
		return;
	}
	// Make all placed ships fire lasers at the clicked point
	for (var k = 0; k < defensiveShips.length; k++) {
		var ship = defensiveShips[k];
		// Only fire from ships that are placed
		if (!ship.placed) {
			continue;
		}
		// Calculate direction from this ship to clicked position
		var dx = x - ship.x;
		var dy = y - ship.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Calculate rotation angle to face the target point
		var targetRotation = Math.atan2(dy, dx) + Math.PI / 2; // Add PI/2 since ship top should face target
		// Rotate the ship to face the target
		tween(ship, {
			rotation: targetRotation
		}, {
			duration: 200,
			easing: tween.easeOut
		});
		var speed = 8;
		var normalizedDx = 0;
		var normalizedDy = 0;
		if (distance > 0) {
			normalizedDx = dx / distance;
			normalizedDy = dy / distance;
		}
		// Fire one or two lasers depending on ship upgrade
		if (ship.hasImprovedLasers) {
			// Fire two lasers with slight spread
			var spreadAngle = 0.1; // Radians for spread
			// First laser (slightly left)
			var laser1 = new Laser();
			laser1.x = ship.x;
			laser1.y = ship.y;
			var angle1 = Math.atan2(normalizedDy, normalizedDx) - spreadAngle;
			laser1.velocityX = Math.cos(angle1) * speed;
			laser1.velocityY = Math.sin(angle1) * speed;
			lasers.push(laser1);
			game.addChild(laser1);
			// Second laser (slightly right)
			var laser2 = new Laser();
			laser2.x = ship.x;
			laser2.y = ship.y;
			var angle2 = Math.atan2(normalizedDy, normalizedDx) + spreadAngle;
			laser2.velocityX = Math.cos(angle2) * speed;
			laser2.velocityY = Math.sin(angle2) * speed;
			lasers.push(laser2);
			game.addChild(laser2);
		} else {
			// Fire single laser
			var laser = new Laser();
			laser.x = ship.x;
			laser.y = ship.y;
			laser.velocityX = normalizedDx * speed;
			laser.velocityY = normalizedDy * speed;
			lasers.push(laser);
			game.addChild(laser);
		}
	}
	// Start laser cooldown for 0.2 seconds
	laserCooldownActive = true;
	var cooldownTarget = {}; // Dummy object for tween
	tween(cooldownTarget, {
		dummy: 1
	}, {
		duration: 200,
		onFinish: function onFinish() {
			laserCooldownActive = false;
		}
	});
};
// Define variables that will be initialized after instructions
var sunX, sunY, sun, planets, mercury, venus, earth, mars, jupiter, saturn, uranus, neptune;
var orbitLines, bullets, lasers, asteroids, asteroidSpawnTimer, lives;
var scoreTxt, livesTxt, defensiveShips, selectedShipIndex, isDragging;
var totalShips, availableShips, lastScoreCheck;
var laserCooldownActive = false;
// Function to initialize game assets
function initializeGameAssets() {
	sunX = 2048 / 2;
	sunY = 2732 / 2;
	sun = game.addChild(LK.getAsset('sun', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: sunX,
		y: sunY
	}));
	planets = [];
	mercury = new Planet(50, 0x8c7853, 150, 0.015);
	venus = new Planet(70, 0xffc649, 200, 0.012);
	earth = new Planet(80, 0x4169e1, 300, 0.008);
	mars = new Planet(60, 0xff4500, 450, 0.005);
	jupiter = new Planet(120, 0xd2691e, 600, 0.003);
	saturn = new Planet(100, 0xffd700, 750, 0.002);
	uranus = new Planet(90, 0x40e0d0, 900, 0.0015);
	neptune = new Planet(85, 0x0080ff, 1050, 0.001);
	planets.push(mercury);
	planets.push(venus);
	planets.push(earth);
	planets.push(mars);
	planets.push(jupiter);
	planets.push(saturn);
	planets.push(uranus);
	planets.push(neptune);
	// Create orbit lines for each planet
	orbitLines = [];
	var planetOrbits = [150, 200, 300, 450, 600, 750, 900, 1050]; // Mercury to Neptune orbit radii
	for (var i = 0; i < planetOrbits.length; i++) {
		var orbitLine = new OrbitLine(planetOrbits[i]);
		orbitLine.x = sunX;
		orbitLine.y = sunY;
		orbitLines.push(orbitLine);
		game.addChild(orbitLine);
	}
	for (var i = 0; i < planets.length; i++) {
		game.addChild(planets[i]);
	}
	bullets = [];
	lasers = [];
	asteroids = [];
	asteroidSpawnTimer = 0;
	lives = 4;
	scoreTxt = new Text2('Score: 0', {
		size: 60,
		fill: 0xFFFFFF
	});
	scoreTxt.anchor.set(0.5, 0);
	scoreTxt.x = 0;
	LK.gui.top.addChild(scoreTxt);
	livesTxt = new Text2('Lives: 4', {
		size: 60,
		fill: 0xFFFFFF
	});
	livesTxt.anchor.set(0.5, 0);
	livesTxt.x = 0;
	livesTxt.y = 70;
	LK.gui.top.addChild(livesTxt);
	defensiveShips = [];
	selectedShipIndex = -1;
	isDragging = false;
	totalShips = 4; // Maximum number of ships
	availableShips = 1; // Start with 1 ship available
	lastScoreCheck = 0; // Track score for adding new ships
	// Create 4 defensive ships but only show the available ones
	for (var i = 0; i < totalShips; i++) {
		var defensiveShip = LK.getAsset('defensiveShip', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -80,
			// Position all ships in the same spot in top right corner
			y: 80
		});
		defensiveShip.shipIndex = i;
		defensiveShip.placed = false;
		defensiveShip.selected = false;
		defensiveShip.requiresConfirmation = false;
		defensiveShip.hasImprovedLasers = false;
		// Only show ships that are available
		defensiveShip.visible = i < availableShips;
		defensiveShips.push(defensiveShip);
		LK.gui.topRight.addChild(defensiveShip);
		// Create "Improve Lasers" text for this ship
		var improveLasersText = new Text2('Improve Lasers', {
			size: 44,
			fill: 0xFFFFFF
		});
		improveLasersText.anchor.set(1, 0.5); // Right anchor to position to left of ship
		improveLasersText.x = -140; // Position further to the left of the ship
		improveLasersText.y = 80;
		improveLasersText.visible = i < availableShips && LK.getScore() >= 75;
		defensiveShip.improveLasersText = improveLasersText; // Store reference on ship
		LK.gui.topRight.addChild(improveLasersText);
		// Create cost text below improve lasers
		var costText = new Text2('Cost: 75 Points', {
			size: 32,
			fill: 0xcccccc
		});
		costText.anchor.set(1, 0.5); // Right anchor to position to left of ship
		costText.x = -140; // Position further to the left of the ship
		costText.y = 110; // Position below improve lasers text
		costText.visible = i < availableShips && LK.getScore() >= 75;
		defensiveShip.costText = costText; // Store reference on ship
		LK.gui.topRight.addChild(costText);
	}
	// Add down handler to each defensive ship
	for (var i = 0; i < defensiveShips.length; i++) {
		defensiveShips[i].down = function (x, y, obj) {
			var ship = this;
			var shipIndex = ship.shipIndex;
			// Only allow interaction with visible/available ships
			if (!ship.visible) {
				return;
			}
			if (ship.placed) {
				// Ship has been placed, allow selection for shooting
				// Deselect all other ships
				for (var j = 0; j < defensiveShips.length; j++) {
					if (j !== shipIndex && defensiveShips[j].selected) {
						defensiveShips[j].selected = false;
						tween(defensiveShips[j], {
							alpha: 1.0
						}, {
							duration: 200
						});
					}
				}
				if (!ship.selected) {
					ship.selected = true;
					selectedShipIndex = shipIndex;
					tween(ship, {
						alpha: 0.7
					}, {
						duration: 200
					});
				}
				// Removed else block to prevent manual dis-selection of placed ships
				return;
			}
			// Ship not placed yet - check if it needs confirmation or can start dragging
			if (!ship.requiresConfirmation) {
				// First click - select ship and require confirmation
				// Deselect all other ships
				for (var j = 0; j < defensiveShips.length; j++) {
					if (j !== shipIndex) {
						defensiveShips[j].selected = false;
						defensiveShips[j].requiresConfirmation = false;
						tween(defensiveShips[j], {
							alpha: 1.0
						}, {
							duration: 200
						});
					}
				}
				// Select this ship and mark it as requiring confirmation
				ship.selected = true;
				ship.requiresConfirmation = true;
				selectedShipIndex = shipIndex;
				tween(ship, {
					alpha: 0.7
				}, {
					duration: 200
				});
			} else {
				// Second click - start dragging
				isDragging = true;
				// Store original scale before moving
				var originalScaleX = ship.scaleX;
				var originalScaleY = ship.scaleY;
				// No need to shift ships since they're all in the same position
				// Move defensive ship to game area for dragging
				var gamePos = game.toLocal(LK.gui.topRight.toGlobal({
					x: ship.x,
					y: ship.y
				}));
				LK.gui.topRight.removeChild(ship);
				game.addChild(ship);
				ship.x = gamePos.x;
				ship.y = gamePos.y;
				// Restore original scale after moving to game area
				ship.scaleX = originalScaleX;
				ship.scaleY = originalScaleY;
			}
		};
	}
}
game.move = function (x, y, obj) {
	// Move ship to cursor position during dragging
	if (isDragging && selectedShipIndex >= 0) {
		var ship = defensiveShips[selectedShipIndex];
		ship.x = x;
		ship.y = y;
	}
};
game.up = function (x, y, obj) {
	if (isDragging && selectedShipIndex >= 0) {
		isDragging = false;
		// Defensive ship is now placed in the solar system
		var placedShip = defensiveShips[selectedShipIndex];
		// Check if ship is off-screen and needs to be moved back to available ships area
		var shipHalfWidth = 40; // Half width of defensive ship (80/2)
		var shipHalfHeight = 55; // Half height of defensive ship (110/2)
		var isOffScreen = placedShip.x - shipHalfWidth < 0 || placedShip.x + shipHalfWidth > 2048 || placedShip.y - shipHalfHeight < 0 || placedShip.y + shipHalfHeight > 2732;
		if (isOffScreen) {
			// Move ship back to available ships area
			game.removeChild(placedShip);
			LK.gui.topRight.addChild(placedShip);
			// Place ship back at the single spawn position in top right corner
			placedShip.x = -80;
			placedShip.y = 80;
			placedShip.placed = false;
		} else {
			placedShip.placed = true;
		}
		placedShip.selected = false;
		selectedShipIndex = -1;
		tween(placedShip, {
			alpha: 1.0
		}, {
			duration: 200
		});
	}
};
game.update = function () {
	// Don't update game while instructions are visible
	if (instructionsVisible) {
		// Spawn asteroids for instruction demonstration
		instructionAsteroidSpawnTimer++;
		if (instructionAsteroidSpawnTimer > 90) {
			// Spawn every 1.5 seconds
			var asteroid = new Asteroid();
			// Randomly choose left or bottom side to spawn from
			var spawnSide = Math.random() < 0.5 ? 'left' : 'bottom';
			if (spawnSide === 'left') {
				// Spawn from left side at random Y position
				asteroid.x = -50;
				asteroid.y = Math.random() * 2732;
			} else {
				// Spawn from bottom side at random X position
				asteroid.x = Math.random() * 2048;
				asteroid.y = 2732 + 50;
			}
			// Calculate direction toward instruction earth
			var dx = instructionEarth.x - asteroid.x;
			var dy = instructionEarth.y - asteroid.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			var speed = 2;
			if (distance > 0) {
				asteroid.velocityX = dx / distance * speed;
				asteroid.velocityY = dy / distance * speed;
			}
			instructionAsteroids.push(asteroid);
			game.addChild(asteroid);
			instructionAsteroidSpawnTimer = 0;
		}
		// Count active instruction lasers
		var activeLasers = 0;
		for (var m = 0; m < instructionAsteroids.length; m++) {
			if (instructionAsteroids[m] instanceof Laser) {
				activeLasers++;
			}
		}
		// Auto-fire from instruction ship every 45 frames (0.75 seconds) - only if no active laser
		if (instructionAsteroidSpawnTimer % 45 === 0 && instructionAsteroids.length > 0 && activeLasers === 0) {
			// Find closest asteroid to instruction ship
			var closestAsteroid = null;
			var closestDistance = Infinity;
			for (var k = 0; k < instructionAsteroids.length; k++) {
				var asteroid = instructionAsteroids[k];
				if (asteroid instanceof Asteroid) {
					var dx = asteroid.x - instructionShip.x;
					var dy = asteroid.y - instructionShip.y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < closestDistance) {
						closestDistance = distance;
						closestAsteroid = asteroid;
					}
				}
			}
			// Fire laser at closest asteroid only if it's visible on screen and not targeting earth
			if (closestAsteroid && closestAsteroid.x >= -50 && closestAsteroid.x <= 2098 && closestAsteroid.y >= -50 && closestAsteroid.y <= 2782) {
				// Check if firing would hit the earth - don't fire if trajectory passes too close to earth
				var dx = closestAsteroid.x - instructionShip.x;
				var dy = closestAsteroid.y - instructionShip.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				// Calculate predicted asteroid position
				var laserSpeed = 8;
				var timeToTarget = distance / laserSpeed;
				var predictedX = closestAsteroid.x + closestAsteroid.velocityX * timeToTarget;
				var predictedY = closestAsteroid.y + closestAsteroid.velocityY * timeToTarget;
				// Check if laser trajectory would pass too close to earth
				var earthDx = instructionEarth.x - instructionShip.x;
				var earthDy = instructionEarth.y - instructionShip.y;
				var targetDx = predictedX - instructionShip.x;
				var targetDy = predictedY - instructionShip.y;
				// Calculate angle between earth direction and target direction
				var earthAngle = Math.atan2(earthDy, earthDx);
				var targetAngle = Math.atan2(targetDy, targetDx);
				var angleDiff = Math.abs(earthAngle - targetAngle);
				if (angleDiff > Math.PI) {
					angleDiff = 2 * Math.PI - angleDiff;
				} // Normalize to shortest angle
				// Only fire if angle difference is greater than 0.3 radians (~17 degrees) to avoid hitting earth
				if (angleDiff > 0.3) {
					var instructionLaser = new Laser();
					instructionLaser.x = instructionShip.x;
					instructionLaser.y = instructionShip.y;
					// Calculate direction to predicted position
					var laserDx = predictedX - instructionLaser.x;
					var laserDy = predictedY - instructionLaser.y;
					var laserDistance = Math.sqrt(laserDx * laserDx + laserDy * laserDy);
					// Add aiming inaccuracy - larger error at longer distances
					var aimError = laserDistance / 300 * 0.15; // Reduced error for better accuracy
					var randomAngleOffset = (Math.random() - 0.5) * aimError; // Random offset between -aimError/2 and +aimError/2
					var baseAngle = Math.atan2(laserDy, laserDx);
					var aimAngle = baseAngle + randomAngleOffset;
					var speed = 8;
					if (laserDistance > 0) {
						instructionLaser.velocityX = Math.cos(aimAngle) * speed;
						instructionLaser.velocityY = Math.sin(aimAngle) * speed;
					}
					// Rotate ship to face target (still accurate rotation for visual effect)
					var targetRotation = Math.atan2(laserDy, laserDx) + Math.PI / 2;
					tween(instructionShip, {
						rotation: targetRotation
					}, {
						duration: 200,
						easing: tween.easeOut
					});
					instructionAsteroids.push(instructionLaser); // Reuse instructionAsteroids array for cleanup
					game.addChild(instructionLaser);
				}
			}
		}
		// Update instruction asteroids and lasers
		for (var i = instructionAsteroids.length - 1; i >= 0; i--) {
			var object = instructionAsteroids[i];
			object.update();
			// Check if it's a laser hitting an asteroid
			if (object instanceof Laser) {
				var laserHit = false;
				for (var j = instructionAsteroids.length - 1; j >= 0 && !laserHit; j--) {
					var target = instructionAsteroids[j];
					if (target instanceof Asteroid && object.intersects(target)) {
						object.destroy();
						instructionAsteroids.splice(i, 1);
						target.destroy();
						instructionAsteroids.splice(j > i ? j - 1 : j, 1);
						laserHit = true;
						if (j < i) {
							i--;
						} // Adjust index since we removed an element before current
						break;
					}
				}
				// Remove laser if off-screen and not hit
				if (!laserHit && (object.x < -100 || object.x > 2148 || object.y < -100 || object.y > 2832)) {
					object.destroy();
					instructionAsteroids.splice(i, 1);
				}
			} else if (object instanceof Asteroid) {
				// Remove asteroids that are off-screen or hit the earth
				if (object.x < -100 || object.x > 2148 || object.y < -100 || object.y > 2832) {
					object.destroy();
					instructionAsteroids.splice(i, 1);
				} else {
					// Check if asteroid hits instruction earth (simple distance check)
					var dx = object.x - instructionEarth.x;
					var dy = object.y - instructionEarth.y;
					var distanceSquared = dx * dx + dy * dy;
					if (distanceSquared < 10000) {
						// Collision distance - flash earth dim red
						tween(instructionEarth, {
							tint: 0x664444
						}, {
							duration: 300,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								tween(instructionEarth, {
									tint: 0xFFFFFF
								}, {
									duration: 300,
									easing: tween.easeOut
								});
							}
						});
						object.destroy();
						instructionAsteroids.splice(i, 1);
					}
				}
			}
		}
		return;
	}
	// Check if we should add a new ship (every 50 points up to 200, then every 100 points)
	var currentScore = LK.getScore();
	var newAvailableShips;
	if (currentScore < 200) {
		// Every 50 points up to 200
		newAvailableShips = Math.min(totalShips, 1 + Math.floor(currentScore / 50));
	} else {
		// After 200: base ships from first 200 points plus additional ships every 100 points starting from 200
		var baseShips = 1 + Math.floor(200 / 50); // Ships earned up to 200 points (5 total: 1 + 4)
		var additionalShips = Math.floor((currentScore - 200) / 100); // Additional ships every 100 points after 200
		newAvailableShips = Math.min(totalShips, baseShips + additionalShips);
	}
	if (newAvailableShips > availableShips) {
		availableShips = newAvailableShips;
		// Make the newly available ship visible
		for (var k = 0; k < availableShips; k++) {
			if (!defensiveShips[k].visible) {
				defensiveShips[k].visible = true;
				defensiveShips[k].improveLasersText.visible = currentScore >= 75;
				defensiveShips[k].costText.visible = currentScore >= 75;
			}
		}
	}
	// Update improve lasers text visibility based on score (already using cached currentScore)
	for (var k = 0; k < availableShips; k++) {
		if (defensiveShips[k].visible) {
			defensiveShips[k].improveLasersText.visible = currentScore >= 75;
			defensiveShips[k].costText.visible = currentScore >= 75;
		}
	}
	for (var i = 0; i < planets.length; i++) {
		planets[i].update();
	}
	// Check if at least one spaceship is placed before spawning asteroids
	var hasPlacedShip = false;
	for (var k = 0; k < defensiveShips.length; k++) {
		if (defensiveShips[k].placed) {
			hasPlacedShip = true;
			break;
		}
	}
	// Only spawn asteroids if a spaceship is placed
	if (hasPlacedShip) {
		asteroidSpawnTimer++;
		// Calculate spawn frequency based on score - gradual increase after score 50
		var baseSpawnDelay = 120;
		var minSpawnDelay = 20; // Higher minimum for less dramatic increase
		var cachedScore = LK.getScore(); // Cache score to avoid multiple calls
		var currentSpawnDelay;
		if (cachedScore < 50) {
			// Normal progression before score 50
			var scoreSpeedUp = Math.floor(cachedScore / 100);
			currentSpawnDelay = Math.max(60, baseSpawnDelay - scoreSpeedUp * 10);
		} else {
			// Gradual increase after score 50 - slower progression
			var excessScore = cachedScore - 50;
			var linearSpeedUp = Math.floor(excessScore / 25); // Reduced frequency: every 25 points instead of 10
			currentSpawnDelay = Math.max(minSpawnDelay, 60 - linearSpeedUp * 1); // Smaller reduction: 1 frame instead of 2
		}
		if (asteroidSpawnTimer > currentSpawnDelay) {
			var asteroid = new Asteroid();
			// Spawn only from bottom and left sides (angles between PI and 2*PI)
			var spawnAngle = Math.PI + Math.random() * Math.PI;
			var spawnDistance = 1500;
			var cosSpawn = Math.cos(spawnAngle);
			var sinSpawn = Math.sin(spawnAngle);
			asteroid.x = sunX + cosSpawn * spawnDistance;
			asteroid.y = sunY + sinSpawn * spawnDistance;
			// Set initial velocity toward Earth's current position
			var dx = earth.x - asteroid.x;
			var dy = earth.y - asteroid.y;
			var distanceSquared = dx * dx + dy * dy;
			if (distanceSquared > 0) {
				var distance = Math.sqrt(distanceSquared);
				// Increase speed based on score after reaching 50 points - much more gradual
				var baseSpeed = 2;
				var speedMultiplier = 1;
				if (cachedScore >= 50) {
					// Very gradual speed increase: 0.2% per point after 50, capped at 2x speed
					var speedIncrease = (cachedScore - 50) * 0.002; // Reduced from 0.02 to 0.002
					speedMultiplier = Math.min(2.0, 1 + speedIncrease); // Cap at 2x speed (reached at score 550)
				}
				var speed = baseSpeed * speedMultiplier / distance; // Cache division
				asteroid.velocityX = dx * speed;
				asteroid.velocityY = dy * speed;
			}
			asteroids.push(asteroid);
			game.addChild(asteroid);
			asteroidSpawnTimer = 0;
		}
	}
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		if (bullet.x < -50 || bullet.x > 2098 || bullet.y < -50 || bullet.y > 2782) {
			bullet.destroy();
			bullets.splice(i, 1);
			continue;
		}
		for (var j = asteroids.length - 1; j >= 0; j--) {
			if (bullet.intersects(asteroids[j])) {
				LK.setScore(LK.getScore() + 5);
				scoreTxt.setText('Score: ' + LK.getScore());
				bullet.destroy();
				bullets.splice(i, 1);
				asteroids[j].destroy();
				asteroids.splice(j, 1);
				break;
			}
		}
	}
	// Update lasers
	for (var i = lasers.length - 1; i >= 0; i--) {
		var laser = lasers[i];
		laser.update();
		if (laser.x < -50 || laser.x > 2098 || laser.y < -50 || laser.y > 2782) {
			laser.destroy();
			lasers.splice(i, 1);
			continue;
		}
		// Check laser collision with asteroids
		var laserHit = false;
		for (var j = asteroids.length - 1; j >= 0 && !laserHit; j--) {
			var asteroid = asteroids[j];
			// Quick distance check before expensive intersects call
			var dx = laser.x - asteroid.x;
			var dy = laser.y - asteroid.y;
			var distanceSquared = dx * dx + dy * dy;
			if (distanceSquared < 900 && laser.intersects(asteroid)) {
				// 30*30 rough collision area
				LK.setScore(LK.getScore() + 5);
				scoreTxt.setText('Score: ' + LK.getScore());
				laser.destroy();
				lasers.splice(i, 1);
				asteroid.destroy();
				asteroids.splice(j, 1);
				laserHit = true;
				break;
			}
		}
	}
	for (var i = asteroids.length - 1; i >= 0; i--) {
		var asteroid = asteroids[i];
		asteroid.update();
		var asteroidHit = false;
		// Cache asteroid position relative to sun
		var dx = asteroid.x - sunX;
		var dy = asteroid.y - sunY;
		var sunDistanceSquared = dx * dx + dy * dy;
		// Check sun collision first (most common)
		if (sunDistanceSquared < 14400) {
			// 120 * 120 = 14400
			asteroid.destroy();
			asteroids.splice(i, 1);
			continue;
		}
		// Early exit if asteroid is far from all planets (optimization)
		var minPlanetDistance = 200; // Approximate max planet radius + safety margin
		if (sunDistanceSquared > 1440000) {
			// 1200 * 1200 - beyond Neptune's orbit
			continue;
		}
		// Count placed ships to determine if immunity should apply
		var placedShipsCount = 0;
		for (var m = 0; m < defensiveShips.length; m++) {
			if (defensiveShips[m].placed) {
				placedShipsCount++;
			}
		}
		// Check asteroid collision with defensive ships first (only if more than one ship is placed)
		if (placedShipsCount > 1) {
			for (var k = 0; k < defensiveShips.length && !asteroidHit; k++) {
				var ship = defensiveShips[k];
				if (ship.placed && asteroid.intersects(ship)) {
					// Flash ship dim red
					tween(ship, {
						tint: 0x664444
					}, {
						duration: 300,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							tween(ship, {
								tint: 0xFFFFFF
							}, {
								duration: 300,
								easing: tween.easeOut
							});
						}
					});
					// Remove the ship
					ship.destroy();
					defensiveShips.splice(k, 1);
					// Adjust availableShips count
					if (availableShips > defensiveShips.length) {
						availableShips = defensiveShips.length;
					}
					asteroid.destroy();
					asteroids.splice(i, 1);
					asteroidHit = true;
					break;
				}
			}
		}
		// Only check planet collisions if not destroyed by sun or ships
		for (var j = 0; j < planets.length && !asteroidHit; j++) {
			var planet = planets[j];
			// Quick distance check before expensive intersects call
			var planetDx = asteroid.x - planet.x;
			var planetDy = asteroid.y - planet.y;
			var planetDistanceSquared = planetDx * planetDx + planetDy * planetDy;
			if (planetDistanceSquared < 10000 && asteroid.intersects(planet)) {
				// 100*100 rough collision area
				if (planet === earth) {
					LK.effects.flashScreen(0x440000, 1000);
					lives--;
					livesTxt.setText('Lives: ' + lives);
					if (lives <= 0) {
						LK.showGameOver();
						return;
					}
				}
				asteroid.destroy();
				asteroids.splice(i, 1);
				asteroidHit = true;
				break;
			}
		}
	}
};