/**** 
* Classes
****/ 
var EnemyShip = Container.expand(function () {
	var self = Container.call(this);
	self.hit = function () {
		if (self.isDestroyed) return; // Already destroyed
		self.health--;
		if (self.health <= 0) {
			self.isDestroyed = true;
			// Optionally, trigger a small visual effect here like a flash
			// LK.effects.flashObject(self, 0xffffff, 100);
		} else {
			// Optionally, visual effect for taking damage but not destroyed
			// LK.effects.flashObject(self, 0xffaaaa, 50);
		}
	};
	self.update = function () {
		if (self.isOffScreen || self.isDestroyed) return; // Don't update if off-screen or destroyed
		self.lastY = self.y; // Update lastY before moving
		self.y += self.speed;
		var gameHeight = 2732;
		// Margin based on sprite size to ensure it's fully off-screen at the bottom
		var margin = self.shipSprite && self.shipSprite.height ? self.shipSprite.height / 2 + 50 : 100;
		// Check if ship moved off the bottom of the screen in this frame
		if (self.lastY <= gameHeight + margin && self.y > gameHeight + margin) {
			self.isOffScreen = true;
		}
	};
	self.shipSprite = self.attachAsset('enemyShipSprite', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 4; // Enemy ships move a bit slower than player projectiles
	self.isOffScreen = false;
	self.lastY = self.y; // Initialize lastY for off-screen detection
	self.health = 1; // Enemy ships can take one hit by default
	self.isDestroyed = false; // Flag to mark if the ship is destroyed
	return self;
});
var FireButton = Container.expand(function () {
	var self = Container.call(this);
	self.buttonSprite = self.attachAsset('fireButtonSprite', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.down = function (x, y, obj) {
		// Check if playerShip exists and projectileSpawnPoint is defined
		if (playerShip && typeof playerShip.currentAngle !== 'undefined' && typeof projectileSpawnPoint !== 'undefined' && playerProjectiles && PlayerProjectile) {
			var newProjectile = new PlayerProjectile(playerShip.currentAngle); // Pass the ship's current firing angle
			newProjectile.x = projectileSpawnPoint.x; // Set initial position from calculated spawn point
			newProjectile.y = projectileSpawnPoint.y;
			// lastY initialization is no longer needed as PlayerProjectile handles its state differently.
			playerProjectiles.push(newProjectile);
			game.addChild(newProjectile); // Add projectiles to the main game stage
			// Future enhancement: LK.getSound('shoot').play(); if a shoot sound is added
		}
	};
	return self;
});
// Red circular fire button
var Joystick = Container.expand(function () {
	var self = Container.call(this);
	self.baseSprite = self.attachAsset('joystickBaseSprite', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.knobSprite = self.attachAsset('joystickKnobSprite', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Maximum distance the knob's center can move from the base's center
	self.radius = self.baseSprite.width / 2 - self.knobSprite.width / 2;
	if (self.radius <= 0) {
		// Ensure a sensible minimum radius
		self.radius = self.baseSprite.width > 0 ? self.baseSprite.width / 4 : 50; // Use 1/4 of base width or 50 if base has no width
	}
	self.isDragging = false;
	self.inputVector = {
		x: 0,
		y: 0
	}; // Normalized output (-1 to 1)
	self.handleDown = function (localX, localY) {
		// localX, localY are relative to the joystick's center (its origin)
		// Check if the touch is within the larger base area to start dragging
		var distSqFromCenter = localX * localX + localY * localY;
		if (distSqFromCenter <= self.baseSprite.width / 2 * (self.baseSprite.width / 2)) {
			self.isDragging = true;
			self.handleMove(localX, localY); // Snap knob to initial touch position
			return true; // Indicates joystick took control
		}
		return false; // Joystick not activated
	};
	self.handleMove = function (localX, localY) {
		if (!self.isDragging) return;
		var dist = Math.sqrt(localX * localX + localY * localY);
		if (dist > self.radius) {
			// Normalize and scale to radius if touch is outside draggable area
			self.knobSprite.x = localX / dist * self.radius;
			self.knobSprite.y = localY / dist * self.radius;
		} else {
			self.knobSprite.x = localX;
			self.knobSprite.y = localY;
		}
		// Calculate normalized input vector
		if (self.radius > 0) {
			self.inputVector.x = self.knobSprite.x / self.radius;
			self.inputVector.y = self.knobSprite.y / self.radius;
		} else {
			// Avoid division by zero if radius is zero
			self.inputVector.x = 0;
			self.inputVector.y = 0;
		}
	};
	self.handleUp = function () {
		if (self.isDragging) {
			self.isDragging = false;
			// Reset knob to center and clear input vector
			self.knobSprite.x = 0;
			self.knobSprite.y = 0;
			self.inputVector.x = 0;
			self.inputVector.y = 0;
		}
	};
	self.getInput = function () {
		return self.inputVector;
	};
	self.isActive = function () {
		return self.isDragging;
	};
	return self;
});
// Projectile class for player's bullets
var PlayerProjectile = Container.expand(function (fireAngle) {
	var self = Container.call(this);
	// Attach bullet sprite
	self.bulletSprite = self.attachAsset('playerBulletSprite', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.angle = fireAngle; // Store the firing angle
	self.speed = 20; // Projectile speed magnitude
	// The playerBulletSprite has orientation:1, meaning it's rotated 90deg clockwise.
	// If original was thin vertical, it's now thin horizontal, "pointing" along its X-axis.
	// So, self.angle directly applies.
	self.bulletSprite.rotation = self.angle;
	self.isOffScreen = false; // Flag to indicate if projectile is off-screen
	// Update method to move projectile
	self.update = function () {
		if (self.isOffScreen) return; // Don't update if already marked off-screen
		self.x += Math.cos(self.angle) * self.speed;
		self.y += Math.sin(self.angle) * self.speed;
		// Check if off-screen
		var gameWidth = 2048;
		var gameHeight = 2732;
		// Margin based on projectile size to ensure it's fully off-screen
		var margin = Math.max(self.bulletSprite.width, self.bulletSprite.height) / 2 + 50;
		if (self.x < -margin || self.x > gameWidth + margin || self.y < -margin || self.y > gameHeight + margin) {
			self.isOffScreen = true;
		}
	}; //{M} // Note: Original L was self.destroy related, removed.
	return self;
});
// PlayerShip class to handle player ship logic and projectile spawn point calculation
var PlayerShip = Container.expand(function () {
	var self = Container.call(this);
	// Attach player ship sprite and set reference for spawn point calculation
	self.shipSprite = self.attachAsset('playerShipSprite', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.moveSpeed = 10; // Pixels per tick for movement speed
	// currentAngle is the direction the ship moves and fires projectiles.
	// 0 radians = right, -PI/2 = up (screen coordinates).
	self.currentAngle = -Math.PI / 2; // Initial angle: pointing up.
	// playerShipSprite is assumed to be designed pointing "up" (its nose along its local -Y axis).
	// To make the sprite's nose align with currentAngle, its visual rotation needs adjustment.
	// Visual rotation = currentAngle + Math.PI / 2.
	// E.g., currentAngle = -PI/2 (up) => visual rotation = 0.
	// E.g., currentAngle = 0 (right) => visual rotation = PI/2.
	self.shipSprite.rotation = self.currentAngle + Math.PI / 2;
	// Initialize projectile spawn point (remains important)
	// This will be updated relative to the ship's current position in self.update()
	// Initial dummy values, will be set correctly on first update.
	projectileSpawnPoint.x = 0;
	projectileSpawnPoint.y = 0;
	self.applyJoystickInput = function (inputX, inputY) {
		// Update angle only if joystick provides directional input
		if (inputX !== 0 || inputY !== 0) {
			self.currentAngle = Math.atan2(inputY, inputX);
			self.shipSprite.rotation = self.currentAngle + Math.PI / 2;
		}
		self.x += inputX * self.moveSpeed;
		self.y += inputY * self.moveSpeed;
		// Boundary checks to keep ship on screen
		var halfWidth = self.shipSprite.width / 2;
		var halfHeight = self.shipSprite.height / 2;
		var gameWidth = 2048;
		var gameHeight = 2732;
		var topSafeMargin = 100; // Top 100px area is reserved
		if (self.x - halfWidth < 0) self.x = halfWidth;
		if (self.x + halfWidth > gameWidth) self.x = gameWidth - halfWidth;
		if (self.y - halfHeight < topSafeMargin) self.y = topSafeMargin + halfHeight;
		if (self.y + halfHeight > gameHeight) self.y = gameHeight - halfHeight;
	};
	// Update projectile spawn point every frame based on player ship position and rotation
	self.update = function () {
		var shipAsset = self.shipSprite;
		if (!shipAsset) return;
		// Calculate spawn point at the tip of the ship, considering its currentAngle.
		// The "nose" is shipAsset.height / 2 distance from the center.
		var noseDistance = shipAsset.height / 2;
		projectileSpawnPoint.x = self.x + Math.cos(self.currentAngle) * noseDistance;
		projectileSpawnPoint.y = self.y + Math.sin(self.currentAngle) * noseDistance;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Projectile spawn point (relative to player ship center)
// Will be updated in PlayerShip class update
var projectileSpawnPoint = {
	x: 0,
	y: 0
};
var joystick; // Declare joystick instance
// Array to keep track of all player projectiles
var playerProjectiles = [];
// Array to keep track of all enemy ships
var enemyShips = [];
// Create player ship and add to game
var playerShip = new PlayerShip();
game.addChild(playerShip);
// Center player ship horizontally, place near bottom
playerShip.x = 2048 / 2;
playerShip.y = 2732 - 350;
// Create Joystick
joystick = new Joystick();
game.addChild(joystick);
// Set initial position (e.g., 0,0), though it will jump to touch.
joystick.x = 0;
joystick.y = 0;
joystick.visible = false; // Joystick starts hidden and will appear at touch position
// Create and add Enemy Ships
var enemyShip1 = new EnemyShip();
var enemyShipAssetHeight1 = enemyShip1.shipSprite && enemyShip1.shipSprite.height ? enemyShip1.shipSprite.height : 146; // Default to asset height
enemyShip1.x = 2048 / 3;
enemyShip1.y = -(enemyShipAssetHeight1 / 2) - 50; // Start off-screen at the top
enemyShip1.lastY = enemyShip1.y; // Initialize lastY
game.addChild(enemyShip1);
enemyShips.push(enemyShip1);
var enemyShip2 = new EnemyShip();
var enemyShipAssetHeight2 = enemyShip2.shipSprite && enemyShip2.shipSprite.height ? enemyShip2.shipSprite.height : 146; // Default to asset height
enemyShip2.x = 2048 * 2 / 3;
enemyShip2.y = -(enemyShipAssetHeight2 / 2) - 150; // Start off-screen, staggered further up
enemyShip2.lastY = enemyShip2.y; // Initialize lastY
game.addChild(enemyShip2);
enemyShips.push(enemyShip2);
// Game event handlers
// Create and position Fire Button
var fireButton = new FireButton();
LK.gui.bottomLeft.addChild(fireButton);
// Position the fire button visually in the bottom-left corner with some margin
// The buttonSprite is 200x200 and anchored at its center (0.5, 0.5)
// fireButton (Container) is added to LK.gui.bottomLeft, positioning its top-left (0,0) at screen bottom-left.
// Adjust x and y to make the button appear correctly.
var buttonMargin = 50; // 50px margin from screen edges
fireButton.x = fireButton.buttonSprite.width / 2 + buttonMargin;
fireButton.y = -fireButton.buttonSprite.height / 2 - buttonMargin; // Negative Y moves up from the bottom edge
game.down = function (x, y, obj) {
	// x, y are global game coordinates
	// Move the joystick to the touch position
	joystick.x = x;
	joystick.y = y;
	joystick.visible = true;
	// Activate the joystick. Since the joystick's origin is now at the touch point (x,y),
	// the local coordinates for the touch within the joystick are (0,0).
	// This centers the knob under the finger and initiates dragging.
	joystick.handleDown(0, 0); // Pass (0,0) as local coordinates
	// Note: With this "floating joystick" implementation, the joystick activates on any screen press.
	// The previous mechanic, where tapping away from a fixed joystick fired projectiles,
	// is superseded. Further design would be needed for a separate firing mechanism.
};
game.move = function (x, y, obj) {
	if (joystick.isActive()) {
		var joystickLocalPos = joystick.toLocal({
			x: x,
			y: y
		});
		joystick.handleMove(joystickLocalPos.x, joystickLocalPos.y);
	}
};
game.up = function (x, y, obj) {
	if (joystick.isActive()) {
		joystick.handleUp(); // Resets knob, inputVector, and isDragging flag
		joystick.visible = false; // Hide the joystick when the touch is released
	}
};
// Update game state
game.update = function () {
	// Apply joystick input to player ship movement
	if (joystick && playerShip && playerShip.applyJoystickInput) {
		var input = joystick.getInput();
		playerShip.applyJoystickInput(input.x, input.y);
	}
	// Update player ship (e.g., to recalculate projectileSpawnPoint after moving)
	if (playerShip && playerShip.update) {
		playerShip.update();
	}
	// Update and clean up projectiles, and check for collisions with enemies
	for (var i = playerProjectiles.length - 1; i >= 0; i--) {
		var proj = playerProjectiles[i];
		if (proj.update) {
			proj.update(); // Call projectile's own update logic (movement)
		}
		// Check if the projectile flagged itself as off-screen AFTER moving
		if (proj.isOffScreen) {
			proj.destroy(); // Destroy the projectile
			playerProjectiles.splice(i, 1); // Remove from the tracking array
			continue; // Move to the next projectile
		}
		// Collision detection with enemy ships
		for (var k = enemyShips.length - 1; k >= 0; k--) {
			var enemy = enemyShips[k];
			// Skip already destroyed or off-screen enemies for collision checks
			if (enemy.isDestroyed || enemy.isOffScreen) {
				continue;
			}
			if (proj.intersects(enemy)) {
				enemy.hit(); // Enemy takes damage, potentially sets isDestroyed = true
				proj.destroy(); // Projectile is consumed on hit
				playerProjectiles.splice(i, 1); // Remove projectile
				// If enemy.isDestroyed became true, it will be handled in the enemyShips loop below.
				// Score will be awarded there too.
				break; // Projectile is gone, no need to check against other enemies
			}
		}
		// If proj was spliced, loop continues correctly to the new element at index i or finishes.
	}
	// Update and clean up enemy ships
	for (var j = enemyShips.length - 1; j >= 0; j--) {
		var enemy = enemyShips[j];
		// First, check if the enemy ship is marked as destroyed (e.g., by a projectile hit)
		if (enemy.isDestroyed) {
			enemy.destroy(); // Destroy the enemy ship
			enemyShips.splice(j, 1); // Remove from the tracking array
			LK.setScore(LK.getScore() + 10); // Award score for destroying an enemy
			// If you have a scoreText object accessible globally, update it here:
			// if (typeof scoreTxt !== 'undefined' && scoreTxt && scoreTxt.setText) {
			//     scoreTxt.setText(LK.getScore());
			// }
			continue; // Move to the next enemy ship in the list
		}
		if (enemy.update) {
			enemy.update(); // Call enemy ship's own update logic (movement, etc.)
		}
		// Then, check if the enemy ship flagged itself as off-screen (if not already destroyed)
		if (enemy.isOffScreen) {
			enemy.destroy(); // Destroy the enemy ship
			enemyShips.splice(j, 1); // Remove from the tracking array
			// No score for merely going off-screen, unless desired.
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -2,17 +2,22 @@
 * Classes
 ****/ 
 var EnemyShip = Container.expand(function () {
 	var self = Container.call(this);
-	self.shipSprite = self.attachAsset('enemyShipSprite', {
-		anchorX: 0.5,
-		anchorY: 0.5
-	});
-	self.speed = 4; // Enemy ships move a bit slower than player projectiles
-	self.isOffScreen = false;
-	self.lastY = self.y; // Initialize lastY for off-screen detection
+	self.hit = function () {
+		if (self.isDestroyed) return; // Already destroyed
+		self.health--;
+		if (self.health <= 0) {
+			self.isDestroyed = true;
+			// Optionally, trigger a small visual effect here like a flash
+			// LK.effects.flashObject(self, 0xffffff, 100);
+		} else {
+			// Optionally, visual effect for taking damage but not destroyed
+			// LK.effects.flashObject(self, 0xffaaaa, 50);
+		}
+	};
 	self.update = function () {
-		if (self.isOffScreen) return;
+		if (self.isOffScreen || self.isDestroyed) return; // Don't update if off-screen or destroyed
 		self.lastY = self.y; // Update lastY before moving
 		self.y += self.speed;
 		var gameHeight = 2732;
 		// Margin based on sprite size to ensure it's fully off-screen at the bottom
@@ -21,8 +26,17 @@
 		if (self.lastY <= gameHeight + margin && self.y > gameHeight + margin) {
 			self.isOffScreen = true;
 		}
 	};
+	self.shipSprite = self.attachAsset('enemyShipSprite', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.speed = 4; // Enemy ships move a bit slower than player projectiles
+	self.isOffScreen = false;
+	self.lastY = self.y; // Initialize lastY for off-screen detection
+	self.health = 1; // Enemy ships can take one hit by default
+	self.isDestroyed = false; // Flag to mark if the ship is destroyed
 	return self;
 });
 var FireButton = Container.expand(function () {
 	var self = Container.call(this);
@@ -301,29 +315,59 @@
 	// Update player ship (e.g., to recalculate projectileSpawnPoint after moving)
 	if (playerShip && playerShip.update) {
 		playerShip.update();
 	}
-	// Update and clean up projectiles
+	// Update and clean up projectiles, and check for collisions with enemies
 	for (var i = playerProjectiles.length - 1; i >= 0; i--) {
 		var proj = playerProjectiles[i];
 		if (proj.update) {
-			proj.update(); // Call projectile's own update logic
+			proj.update(); // Call projectile's own update logic (movement)
 		}
-		// Check if the projectile flagged itself as off-screen
+		// Check if the projectile flagged itself as off-screen AFTER moving
 		if (proj.isOffScreen) {
-			proj.destroy(); // Destroy the projectile (can only be called from Game class context)
+			proj.destroy(); // Destroy the projectile
 			playerProjectiles.splice(i, 1); // Remove from the tracking array
+			continue; // Move to the next projectile
 		}
+		// Collision detection with enemy ships
+		for (var k = enemyShips.length - 1; k >= 0; k--) {
+			var enemy = enemyShips[k];
+			// Skip already destroyed or off-screen enemies for collision checks
+			if (enemy.isDestroyed || enemy.isOffScreen) {
+				continue;
+			}
+			if (proj.intersects(enemy)) {
+				enemy.hit(); // Enemy takes damage, potentially sets isDestroyed = true
+				proj.destroy(); // Projectile is consumed on hit
+				playerProjectiles.splice(i, 1); // Remove projectile
+				// If enemy.isDestroyed became true, it will be handled in the enemyShips loop below.
+				// Score will be awarded there too.
+				break; // Projectile is gone, no need to check against other enemies
+			}
+		}
+		// If proj was spliced, loop continues correctly to the new element at index i or finishes.
 	}
 	// Update and clean up enemy ships
 	for (var j = enemyShips.length - 1; j >= 0; j--) {
 		var enemy = enemyShips[j];
+		// First, check if the enemy ship is marked as destroyed (e.g., by a projectile hit)
+		if (enemy.isDestroyed) {
+			enemy.destroy(); // Destroy the enemy ship
+			enemyShips.splice(j, 1); // Remove from the tracking array
+			LK.setScore(LK.getScore() + 10); // Award score for destroying an enemy
+			// If you have a scoreText object accessible globally, update it here:
+			// if (typeof scoreTxt !== 'undefined' && scoreTxt && scoreTxt.setText) {
+			//     scoreTxt.setText(LK.getScore());
+			// }
+			continue; // Move to the next enemy ship in the list
+		}
 		if (enemy.update) {
-			enemy.update(); // Call enemy ship's own update logic
+			enemy.update(); // Call enemy ship's own update logic (movement, etc.)
 		}
-		// Check if the enemy ship flagged itself as off-screen
+		// Then, check if the enemy ship flagged itself as off-screen (if not already destroyed)
 		if (enemy.isOffScreen) {
 			enemy.destroy(); // Destroy the enemy ship
 			enemyShips.splice(j, 1); // Remove from the tracking array
+			// No score for merely going off-screen, unless desired.
 		}
 	}
 };
\ No newline at end of file