===================================================================
--- original.js
+++ change.js
@@ -1,101 +1,209 @@
 /**** 
 * Classes
 ****/ 
-var PlayerShip = Container.expand(function () {
+// EnemyShip Class: Represents an enemy spacecraft.
+var EnemyShip = Container.expand(function () {
 	var self = Container.call(this);
-	// ---- METHODS ----
-	// Call this to move the ship. Coordinates are in game space.
-	self.moveTo = function (x, y) {
-		// Ensure shipGraphics exists and has dimensions before using them.
-		// Fallback values are based on the asset definition if shipGraphics isn't ready,
-		// though it should be after attachAsset.
-		var halfWidth = self.shipGraphics ? self.shipGraphics.width / 2 : 50; // Default based on 100 width
-		var halfHeight = self.shipGraphics ? self.shipGraphics.height / 2 : 60; // Default based on 120 height
-		// Define screen boundaries for clamping
-		// Top boundary must ensure the ship's top edge is below y=100 (LK menu area)
-		var minY = 100 + halfHeight;
-		var maxY = 2732 - halfHeight; // Game height is 2732
-		var minX = halfWidth;
-		var maxX = 2048 - halfWidth; // Game width is 2048
-		self.x = Math.max(minX, Math.min(x, maxX));
-		self.y = Math.max(minY, Math.min(y, maxY));
+	self.attachAsset('enemyShipSprite', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.speed = 4; // Pixels per frame, moving downwards. Can be varied for difficulty.
+	// Called automatically by LK engine if the instance is added to the game stage.
+	self.update = function () {
+		self.y += self.speed;
 	};
-	// ---- INITIALIZATION ----
-	// Attach the visual asset for the player ship.
-	// The LK engine will automatically create 'playerShipAsset' based on these properties
-	// if it doesn't exist.
-	self.shipGraphics = self.attachAsset('playerShipAsset', {
-		width: 100,
-		// The width of our ship
-		height: 120,
-		// The height of our ship
-		color: 0x00EE00,
-		// A vibrant green!
-		shape: 'box',
-		// For now, a simple box. We can make it cooler later!
+	return self;
+});
+// PlayerBullet Class: Represents bullets fired by the player.
+var PlayerBullet = Container.expand(function () {
+	var self = Container.call(this);
+	self.attachAsset('playerBulletSprite', {
 		anchorX: 0.5,
-		// Anchor to the center for easier rotation and positioning
 		anchorY: 0.5
 	});
-	// If our ship asset was, for example, drawn facing right, and we want it to point upwards:
-	// self.shipGraphics.rotation = -Math.PI / 2; // Rotates -90 degrees
-	return self; // Absolutely essential for class structure!
+	self.speed = -15; // Pixels per frame, negative for moving upwards.
+	// Called automatically by LK engine.
+	self.update = function () {
+		self.y += self.speed;
+	};
+	return self;
 });
+// For when the player's ship is destroyed
+// No plugins are explicitly required for this MVP of Starship Onslaught.
+// PlayerShip Class: Represents the player's controllable starship.
+var PlayerShip = Container.expand(function () {
+	var self = Container.call(this);
+	// Attach the visual asset for the player's ship.
+	// The asset is anchored by its center within the container.
+	// The container's (self) x,y coordinates remain its top-left.
+	self.attachAsset('playerShipSprite', {
+		anchorX: 0.5,
+		anchorY: 0.5
+		// The graphic's local position is set to be the center of the container,
+		// assuming the container's width/height match the sprite's dimensions.
+		// This is implicitly handled if the container sizes to its children.
+		// For an 80x100 sprite, this places its center at container's (40,50).
+		// However, standard behavior for attachAsset might be that the child is added at (0,0) locally,
+		// and anchorX/Y refers to the texture anchor. So the visual sprite is centered around (0,0) of PlayerShip's local space.
+		// The container will automatically size based on its children. If the sprite is 80x100,
+		// centered at local (0,0), its bounds are -40 to +40 (x) and -50 to +50 (y).
+		// This means player.width and player.height would be 80 and 100, and player.x/y refers to its visual center.
+		// Let's stick to LK example: anchorX/Y for the *asset*, container x/y is top-left.
+		// The asset child will be added at (0,0) in container space. If its own anchor is 0.5,0.5,
+		// its visual center is at its (0,0) local position.
+		// The container's width/height will be that of the asset.
+		// Thus, player.x, player.y means the top-left of the bounding box of the player ship.
+	});
+	// Player movement and shooting are handled in the main game logic.
+	return self;
+});
 
 /**** 
 * Initialize Game
 ****/ 
-// Global variables for game state
+// Create the game instance with a dark space-like background.
 var game = new LK.Game({
-	backgroundColor: 0x100030 // A nice dark blue/purple for the vastness of space!
+	backgroundColor: 0x0A0A20 // Dark blue, almost black
 });
 
 /**** 
 * Game Code
 ****/ 
-// Global variables for game state
-var playerShip; // Our hero, the player's ship!
-var draggingPlayer = false; // To track if we're currently dragging the ship
-// Initialize the PlayerShip
-playerShip = new PlayerShip();
-// Set the initial position for the player ship.
-// We want it centered horizontally and near the bottom of the screen.
-var initialPlayerX = 2048 / 2;
-// Ensure shipGraphics and its height are available for positioning.
-// Default to asset's defined height (120) if somehow not ready.
-var shipHeight = playerShip.shipGraphics ? playerShip.shipGraphics.height : 120;
-var initialPlayerY = 2732 - shipHeight * 1.5; // Positioned 1.5 times its height from the bottom
-playerShip.x = initialPlayerX;
-playerShip.y = initialPlayerY;
-// Call moveTo once to ensure the initial position is clamped correctly within bounds.
-if (playerShip.moveTo) {
-	// Check if moveTo method exists
-	playerShip.moveTo(playerShip.x, playerShip.y);
-}
-game.addChild(playerShip); // Add our shiny new ship to the game!
-// Touch Controls for Player Movement
-// These handlers will use the x, y coordinates provided by LK,
-// which are already in game space.
-// Called when a touch/mouse press begins anywhere on the game screen
+// Sound effects
+// Player's bullets
+// Enemy spacecraft
+// Player's starship
+// Initialize assets used in this game.
+// Define game-wide constants
+var PLAYER_SHOOT_INTERVAL_TICKS = 25; // Player shoots roughly every 0.4 seconds (60/25)
+var ENEMY_SPAWN_INTERVAL_TICKS = 75; // New enemy spawns roughly every 1.25 seconds (60/75)
+var GAME_WIDTH = 2048;
+var GAME_HEIGHT = 2732;
+// Declare game state variables
+var player;
+var enemies = [];
+var playerBullets = [];
+var scoreTxt;
+var dragNode = null; // To keep track of the object being dragged (player's ship)
+// Initialize and display the score
+scoreTxt = new Text2('Score: 0', {
+	// Added "Score: " prefix for clarity
+	size: 80,
+	// Readable size for mobile
+	fill: 0xE0E0E0 // Light gray for score text
+});
+scoreTxt.anchor.set(0.5, 0); // Anchor to the horizontal center and vertical top of the text
+// Position score display at the top-center of the GUI layer
+LK.gui.top.addChild(scoreTxt);
+scoreTxt.y = 30; // Provide some padding from the very top edge, clear of potential top-left menu icon
+// Create and position the player's ship
+player = new PlayerShip();
+game.addChild(player);
+// Set initial position: horizontally centered, towards the bottom of the screen.
+// player.width/height are dimensions of the PlayerShip container, derived from its sprite.
+// player.x, player.y refers to the top-left corner of the player ship container.
+player.x = (GAME_WIDTH - player.width) / 2;
+player.y = GAME_HEIGHT - player.height - 60; // 60px padding from the bottom edge
+// Event handler for touch/mouse down (start of drag)
 game.down = function (x, y, obj) {
-	// Let's assume any touch down is intended to control the player ship
-	draggingPlayer = true;
-	if (playerShip && playerShip.moveTo) {
-		playerShip.moveTo(x, y); // Move ship to the initial touch point
-	}
+	// Assume any touch/click initiates player control
+	dragNode = player;
+	// Immediately update player position based on the touch/click
+	handleMove(x, y, obj);
 };
-// Called when a touch/mouse is moved while pressed
-game.move = function (x, y, obj) {
-	if (draggingPlayer && playerShip && playerShip.moveTo) {
-		playerShip.moveTo(x, y); // Update ship's position to the current touch point
-	}
-};
-// Called when a touch/mouse press is released
+// Event handler for touch/mouse up (end of drag)
 game.up = function (x, y, obj) {
-	draggingPlayer = false; // Stop dragging
+	dragNode = null; // Stop dragging
 };
-// Main game update loop - will be used for more game logic later!
+// Unified move handler for player ship control
+function handleMove(x, y, obj) {
+	if (dragNode) {
+		// The incoming x, y are in game coordinates.
+		// Adjust so the player's visual center follows the touch point.
+		var newPlayerX = x - dragNode.width / 2;
+		var newPlayerY = y - dragNode.height / 2;
+		// Constrain player ship within screen boundaries.
+		// dragNode.x, dragNode.y is top-left of the player ship.
+		dragNode.x = Math.max(0, Math.min(GAME_WIDTH - dragNode.width, newPlayerX));
+		dragNode.y = Math.max(0, Math.min(GAME_HEIGHT - dragNode.height, newPlayerY));
+	}
+}
+// Assign the move handler to the game's move event.
+game.move = handleMove;
+// Main game update loop, called every frame by the LK engine.
 game.update = function () {
-	// For now, player movement is event-driven.
-	// We can add other per-frame logic here, like checking for collisions or firing bullets.
+	// Player Shooting Logic
+	if (LK.ticks % PLAYER_SHOOT_INTERVAL_TICKS === 0) {
+		var newBullet = new PlayerBullet();
+		// Spawn bullet from the player ship's "nose" (top-center).
+		// newBullet.x, newBullet.y is top-left of the bullet container.
+		newBullet.x = player.x + player.width / 2 - newBullet.width / 2;
+		newBullet.y = player.y - newBullet.height; // Bullet appears just above the player
+		newBullet.lastY = newBullet.y; // Initialize for off-screen transition detection
+		playerBullets.push(newBullet);
+		game.addChild(newBullet);
+		LK.getSound('playerShootSound').play();
+	}
+	// Enemy Spawning Logic
+	if (LK.ticks % ENEMY_SPAWN_INTERVAL_TICKS === 0) {
+		var newEnemy = new EnemyShip();
+		// Spawn enemy at a random X position, just off-screen at the top.
+		newEnemy.x = Math.random() * (GAME_WIDTH - newEnemy.width);
+		newEnemy.y = -newEnemy.height; // Starts just above the visible screen
+		newEnemy.lastY = newEnemy.y; // Initialize for off-screen transition
+		newEnemy.lastPlayerIntersecting = false; // Initialize for player collision transition
+		enemies.push(newEnemy);
+		game.addChild(newEnemy);
+	}
+	// Update Player Bullets (movement, off-screen removal, collision with enemies)
+	for (var i = playerBullets.length - 1; i >= 0; i--) {
+		var bullet = playerBullets[i];
+		// bullet.update() is automatically called by LK engine for movement.
+		// Off-screen check (bullet moving upwards)
+		// Check if bullet's bottom edge (bullet.y + bullet.height) has crossed screen top (y=0)
+		if (bullet.y + bullet.height < 0 && bullet.lastY + bullet.height >= 0) {
+			bullet.destroy();
+			playerBullets.splice(i, 1);
+			continue; // Skip to next bullet
+		}
+		bullet.lastY = bullet.y; // Update lastY for next frame's transition check
+		// Collision with Enemies
+		for (var j = enemies.length - 1; j >= 0; j--) {
+			var enemy = enemies[j];
+			if (bullet.intersects(enemy)) {
+				LK.setScore(LK.getScore() + 10); // Increment score
+				scoreTxt.setText('Score: ' + LK.getScore()); // Update score display
+				LK.getSound('enemyExplosionSound').play();
+				bullet.destroy(); // Destroy the bullet
+				playerBullets.splice(i, 1);
+				enemy.destroy(); // Destroy the enemy
+				enemies.splice(j, 1);
+				break; // Bullet hit one enemy, so it's gone.
+			}
+		}
+	}
+	// Update Enemies (movement, off-screen removal, collision with player)
+	for (var k = enemies.length - 1; k >= 0; k--) {
+		var enemy = enemies[k];
+		// enemy.update() is automatically called by LK engine.
+		// Off-screen check (enemy moving downwards)
+		// Check if enemy's top edge (enemy.y) has crossed screen bottom (y=GAME_HEIGHT)
+		if (enemy.y > GAME_HEIGHT && enemy.lastY <= GAME_HEIGHT) {
+			enemy.destroy();
+			enemies.splice(k, 1);
+			continue; // Skip to next enemy
+		}
+		enemy.lastY = enemy.y; // Update lastY for next frame
+		// Collision with Player
+		var currentPlayerIntersecting = player.intersects(enemy);
+		// Trigger game over only on the frame the intersection starts.
+		if (!enemy.lastPlayerIntersecting && currentPlayerIntersecting) {
+			LK.getSound('playerExplosionSound').play();
+			// LK.effects.flashScreen(0xFF0000, 300); // Optional screen flash
+			LK.showGameOver(); // End the game
+			return; // Exit update loop as game is over.
+		}
+		enemy.lastPlayerIntersecting = currentPlayerIntersecting; // Update intersection state
+	}
 };
\ No newline at end of file