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

/**** 
* Classes
****/ 
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Enemy properties
	self.health = 1;
	self.speed = 2;
	self.scoreValue = 100;
	self.fireRate = 120; // Ticks between shots
	self.lastShot = Math.floor(Math.random() * 60); // Randomize initial shot timer
	self.movementPattern = Math.floor(Math.random() * 3); // 0: straight, 1: zigzag, 2: circular
	self.movementCounter = 0;
	// Initial target position (will be set during movement)
	self.targetX = null;
	self.update = function () {
		// Basic downward movement
		self.y += self.speed;
		// Apply movement pattern
		if (self.movementPattern === 1) {
			// Zigzag with occasional side movement
			self.x += Math.sin(self.movementCounter * 0.05) * 3;
			// Occasionally move to a different horizontal position
			if (self.movementCounter % 500 === 0) {
				// Choose a new target position on the opposite side
				self.targetX = self.x < GAME_WIDTH / 2 ? GAME_WIDTH * 0.7 + Math.random() * GAME_WIDTH * 0.2 : GAME_WIDTH * 0.1 + Math.random() * GAME_WIDTH * 0.2;
			}
			if (self.targetX) {
				var diffX = self.targetX - self.x;
				if (Math.abs(diffX) > 10) {
					self.x += diffX * 0.03;
				}
			}
			self.movementCounter++;
		} else if (self.movementPattern === 2) {
			// Circular with occasional repositioning
			self.x += Math.sin(self.movementCounter * 0.03) * 4;
			// Occasionally reset position to avoid grouping
			if (self.movementCounter % 700 === 0) {
				// Move to random position on screen
				self.targetX = Math.random() * GAME_WIDTH * 0.8 + GAME_WIDTH * 0.1;
			}
			// Move toward target if exists
			if (self.targetX) {
				var diffX = self.targetX - self.x;
				if (Math.abs(diffX) > 10) {
					self.x += diffX * 0.02;
				}
			}
			self.movementCounter++;
		} else {
			// Add movement for straight pattern (pattern 0)
			if (self.movementCounter % 900 === 0) {
				// Occasional side movement
				self.targetX = Math.random() * GAME_WIDTH * 0.8 + GAME_WIDTH * 0.1;
			}
			// Move toward target if exists
			if (self.targetX) {
				var diffX = self.targetX - self.x;
				if (Math.abs(diffX) > 10) {
					self.x += diffX * 0.01;
				}
			}
			self.movementCounter++;
		}
	};
	// Take damage and check if destroyed
	self.takeDamage = function (amount) {
		self.health -= amount;
		if (self.health <= 0) {
			return true; // Enemy is destroyed
		}
		return false;
	};
	return self;
});
var EnemyBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('enemyBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 7; // Moving downward
	self.update = function () {
		self.y += self.speed;
	};
	return self;
});
var HealthBar = Container.expand(function () {
	var self = Container.call(this);
	// Health bar properties
	self.maxHealth = 4;
	self.currentHealth = 4;
	self.width = 140;
	self.height = 20;
	// Create background bar (gray)
	var background = self.attachAsset('healthbar', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1,
		// Adjust to match bar width
		scaleY: 1,
		// Adjust to match bar height
		tint: 0x666666 // Gray color
	});
	// Create foreground bar (health indicator - green)
	var foreground = self.attachAsset('healthbar', {
		anchorX: 0,
		anchorY: 0.5,
		scaleX: 1,
		// Adjust to match bar width 
		scaleY: 1,
		// Adjust to match bar height
		tint: 0x00FF00 // Green color
	});
	// Center the foreground bar
	foreground.x = -background.width / 2;
	// Update health bar visual based on current health
	self.updateHealth = function (health) {
		self.currentHealth = health;
		// Update the scale of the foreground bar based on current health
		var healthPercentage = Math.max(self.currentHealth / self.maxHealth, 0);
		// Scale should decrease as health decreases, not increase
		// Ensure that we don't go to 0 until health is actually 0
		if (self.currentHealth > 0) {
			// For non-zero health, ensure we have at least a small visible portion of health bar
			foreground.scale.x = Math.max(healthPercentage, 0.05);
		} else {
			// Only when health is truly zero, set scale to zero
			foreground.scale.x = 0;
		}
		// Change color based on health level
		if (healthPercentage > 0.6) {
			foreground.tint = 0x00FF00; // Green
		} else if (healthPercentage > 0.3) {
			foreground.tint = 0xFFFF00; // Yellow
		} else {
			foreground.tint = 0xFF0000; // Red
		}
	};
	return self;
});
var PlayerBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('playerBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = -15; // Moving upward
	self.power = 1;
	self.direction = 'up'; // up, down, left, right
	self.isPiercing = false;
	self.isBouncing = false;
	self.bounceCount = 0;
	self.maxBounces = 3;
	self.update = function () {
		// Move bullet based on direction
		if (self.direction === 'up') {
			self.y += self.speed;
			// Check for bouncing against top edge
			if (self.isBouncing && self.y < 0 && self.bounceCount < self.maxBounces) {
				self.direction = 'down';
				self.bounceCount++;
			}
		} else if (self.direction === 'down') {
			self.y -= self.speed; // Note: speed is negative, so this is adding a positive value
			// Check for bouncing against bottom edge
			if (self.isBouncing && self.y > GAME_HEIGHT && self.bounceCount < self.maxBounces) {
				self.direction = 'up';
				self.bounceCount++;
			}
		} else if (self.direction === 'left') {
			self.x += self.speed;
			// Check for bouncing against left edge
			if (self.isBouncing && self.x < 0 && self.bounceCount < self.maxBounces) {
				self.direction = 'right';
				self.bounceCount++;
			}
		} else if (self.direction === 'right') {
			self.x -= self.speed; // Note: speed is negative, so this is adding a positive value
			// Check for bouncing against right edge
			if (self.isBouncing && self.x > GAME_WIDTH && self.bounceCount < self.maxBounces) {
				self.direction = 'left';
				self.bounceCount++;
			}
		}
	};
	return self;
});
var PlayerShip = Container.expand(function () {
	var self = Container.call(this);
	// Visual representation
	var shipGraphics = self.attachAsset('playerShip', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Shield visual (initially invisible)
	var shieldGraphics = self.attachAsset('shield', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	// Player properties
	self.speed = 10;
	self.fireRate = 20; // Ticks between shots
	self.lastShot = 0;
	self.health = 4; // Player starts with 4 health
	self.healthBar = new HealthBar();
	self.healthBar.y = -80; // Position above player
	self.healthBar.x = 0; // Perfectly center the healthbar with the ship
	self.addChild(self.healthBar);
	self.shieldActive = false;
	self.powerUpActive = false;
	self.quadBulletsActive = false;
	self.rotationSpeed = 0;
	// Physics properties for smooth movement
	self.targetX = null;
	self.targetY = null;
	self.isMoving = false;
	self.moveTween = null;
	// Update method for rotation
	self.update = function () {
		if (self.quadBulletsActive) {
			shipGraphics.rotation += self.rotationSpeed;
		}
	};
	// Shield activation
	self.activateShield = function () {
		self.shieldActive = true;
		shieldGraphics.alpha = 0.5;
		// Shield times out after 5 seconds
		LK.setTimeout(function () {
			self.shieldActive = false;
			shieldGraphics.alpha = 0;
		}, 5000);
	};
	// Power-up activation
	self.activatePowerUp = function () {
		self.powerUpActive = true;
		shipGraphics.tint = 0xf1c40f; // Yellow tint for power-up
		self.fireRate = 10; // Faster firing
		// Power-up times out after 7 seconds
		LK.setTimeout(function () {
			self.powerUpActive = false;
			shipGraphics.tint = 0xFFFFFF;
			self.fireRate = 20;
		}, 7000);
	};
	// Quad bullets activation
	self.activateQuadBullets = function () {
		self.quadBulletsActive = true;
		shipGraphics.tint = 0xe74c3c; // Red tint for quad bullets
		self.fireRate = 15; // Medium firing speed
		self.rotationSpeed = 0.05; // Start spinning
		// Quad bullets time out after 8 seconds
		LK.setTimeout(function () {
			self.quadBulletsActive = false;
			shipGraphics.tint = 0xFFFFFF;
			self.fireRate = 20;
			self.rotationSpeed = 0;
			shipGraphics.rotation = 0; // Reset rotation
		}, 8000);
	};
	return self;
});
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var powerUpGraphics = self.attachAsset('powerUp', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 3;
	// Add quad bullet type with 1/3 chance
	var rand = Math.random();
	if (rand < 0.33) {
		self.type = 'shield';
	} else if (rand < 0.66) {
		self.type = 'weapon';
	} else {
		self.type = 'quadBullets';
	}
	// Set color based on type
	if (self.type === 'shield') {
		powerUpGraphics.tint = 0x3498db; // Blue for shield
	} else if (self.type === 'weapon') {
		powerUpGraphics.tint = 0xf1c40f; // Yellow for weapon
	} else {
		powerUpGraphics.tint = 0xe74c3c; // Red for quad bullets
	}
	self.update = function () {
		self.y += self.speed;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game constants
var GAME_WIDTH = 2048;
var GAME_HEIGHT = 2732;
var SPAWN_ENEMY_INTERVAL = 60; // Spawn enemy every 60 ticks initially
var SPAWN_POWERUP_INTERVAL = 600; // Spawn power-up every 600 ticks
var MIN_SPAWN_INTERVAL = 20; // Minimum spawn rate as difficulty increases
// Game state variables
var player;
var playerBullets = [];
var enemies = [];
var enemyBullets = [];
var powerUps = [];
var gameLevel = 1;
var spawnCounter = 0;
var powerUpCounter = 0;
var isGameActive = true;
var score = 0;
// Initialize score display
var scoreTxt = new Text2('SCORE: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
scoreTxt.y = 30;
// Initialize level display
var levelTxt = new Text2('LEVEL: 1', {
	size: 60,
	fill: 0xFFFFFF
});
levelTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(levelTxt);
levelTxt.y = 100;
// Create player ship
function initializeGame() {
	player = new PlayerShip();
	player.x = GAME_WIDTH / 2;
	player.y = GAME_HEIGHT - 200;
	game.addChild(player);
	// Reset arrays
	playerBullets = [];
	enemies = [];
	enemyBullets = [];
	powerUps = [];
	// Reset game state
	gameLevel = 1;
	spawnCounter = 0;
	powerUpCounter = 0;
	isGameActive = true;
	// Reset score and update display
	LK.setScore(0);
	score = 0;
	updateScoreDisplay();
	updateLevelDisplay();
	// Play background music
	LK.playMusic('gameMusic');
}
// Initialize the game
initializeGame();
// Update score display
function updateScoreDisplay() {
	scoreTxt.setText('SCORE: ' + score);
}
// Update level display
function updateLevelDisplay() {
	levelTxt.setText('LEVEL: ' + gameLevel);
}
// Player shooting
function playerShoot() {
	// Check fire rate cooldown
	if (LK.ticks - player.lastShot < player.fireRate) {
		return;
	}
	// Always fire dual cannons (left and right)
	var bulletLeft = new PlayerBullet();
	bulletLeft.x = player.x - 20;
	bulletLeft.y = player.y - 40;
	bulletLeft.direction = 'up';
	game.addChild(bulletLeft);
	playerBullets.push(bulletLeft);
	var bulletRight = new PlayerBullet();
	bulletRight.x = player.x + 20;
	bulletRight.y = player.y - 40;
	bulletRight.direction = 'up';
	game.addChild(bulletRight);
	playerBullets.push(bulletRight);
	// Triple bullets if weapon power-up is active
	if (player.powerUpActive) {
		var bulletCenter = new PlayerBullet();
		bulletCenter.x = player.x;
		bulletCenter.y = player.y - 50;
		bulletCenter.direction = 'up';
		game.addChild(bulletCenter);
		playerBullets.push(bulletCenter);
	}
	// Quad-directional bullets if quad bullets power-up is active
	if (player.quadBulletsActive) {
		// Up bullet already covered
		// Down bullet
		var bulletDown = new PlayerBullet();
		bulletDown.x = player.x;
		bulletDown.y = player.y + 40;
		bulletDown.direction = 'down';
		bulletDown.isPiercing = true;
		bulletDown.isBouncing = true;
		game.addChild(bulletDown);
		playerBullets.push(bulletDown);
		// Left bullet
		var bulletLeft = new PlayerBullet();
		bulletLeft.x = player.x - 40;
		bulletLeft.y = player.y;
		bulletLeft.direction = 'left';
		bulletLeft.isPiercing = true;
		bulletLeft.isBouncing = true;
		game.addChild(bulletLeft);
		playerBullets.push(bulletLeft);
		// Right bullet
		var bulletRight = new PlayerBullet();
		bulletRight.x = player.x + 40;
		bulletRight.y = player.y;
		bulletRight.direction = 'right';
		bulletRight.isPiercing = true;
		bulletRight.isBouncing = true;
		game.addChild(bulletRight);
		playerBullets.push(bulletRight);
	}
	// Play sound and reset shot timer
	LK.getSound('playerShoot').play();
	player.lastShot = LK.ticks;
}
// Enemy shooting
function enemyShoot(enemy) {
	if (LK.ticks - enemy.lastShot < enemy.fireRate) {
		return;
	}
	var bullet = new EnemyBullet();
	bullet.x = enemy.x;
	bullet.y = enemy.y + 40;
	game.addChild(bullet);
	enemyBullets.push(bullet);
	LK.getSound('enemyShoot').play();
	enemy.lastShot = LK.ticks;
}
// Spawn new enemy
function spawnEnemy() {
	var enemy = new Enemy();
	// Distribute enemies better across the screen width
	// Check if we have other enemies and avoid spawning too close to them
	if (enemies.length > 0) {
		// Find a position away from other enemies
		var attempts = 0;
		var potentialX;
		var validPosition = false;
		while (!validPosition && attempts < 10) {
			potentialX = Math.random() * (GAME_WIDTH - 100) + 50;
			validPosition = true;
			// Check distance from existing enemies
			for (var i = 0; i < enemies.length; i++) {
				if (Math.abs(enemies[i].x - potentialX) < 150) {
					validPosition = false;
					break;
				}
			}
			attempts++;
		}
		enemy.x = validPosition ? potentialX : Math.random() * (GAME_WIDTH - 100) + 50;
	} else {
		enemy.x = Math.random() * (GAME_WIDTH - 100) + 50;
	}
	enemy.y = -50;
	// Increase difficulty with levels
	if (gameLevel > 1) {
		enemy.speed = Math.min(2 + gameLevel * 0.5, 6);
		enemy.health = Math.min(1 + Math.floor(gameLevel / 3), 3);
	}
	if (gameLevel > 5) {
		enemy.fireRate = Math.max(120 - gameLevel * 5, 60);
	}
	game.addChild(enemy);
	enemies.push(enemy);
}
// Spawn power-up
function spawnPowerUp() {
	var powerUp = new PowerUp();
	powerUp.x = Math.random() * (GAME_WIDTH - 100) + 50;
	powerUp.y = -50;
	game.addChild(powerUp);
	powerUps.push(powerUp);
}
// Check level progress
function checkLevelProgress() {
	// Advance level based on score
	var shouldAdvanceLevel = Math.floor(score / 1000) + 1;
	if (shouldAdvanceLevel > gameLevel) {
		gameLevel = shouldAdvanceLevel;
		updateLevelDisplay();
		// Flash screen to indicate level up
		LK.effects.flashScreen(0x3498db, 500);
	}
}
// Handle collisions
function handleCollisions() {
	// Check player bullets hitting enemies
	for (var i = playerBullets.length - 1; i >= 0; i--) {
		var bullet = playerBullets[i];
		var bulletHit = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (bullet.intersects(enemy)) {
				// Enemy takes damage
				if (enemy.takeDamage(bullet.power)) {
					// Enemy destroyed
					score += enemy.scoreValue;
					LK.setScore(score);
					updateScoreDisplay();
					LK.getSound('explosion').play();
					LK.effects.flashObject(enemy, 0xff0000, 300);
					// Remove enemy
					enemy.destroy();
					enemies.splice(j, 1);
				}
				// Only remove non-piercing bullets on hit
				if (!bullet.isPiercing) {
					bullet.destroy();
					playerBullets.splice(i, 1);
					bulletHit = true;
					break;
				}
			}
		}
		// If a non-piercing bullet hit something, skip to the next bullet
		if (bulletHit) {
			continue;
		}
	}
	// Check enemy bullets hitting player
	for (var i = enemyBullets.length - 1; i >= 0; i--) {
		var bullet = enemyBullets[i];
		if (bullet.intersects(player)) {
			// Player hit
			bullet.destroy();
			enemyBullets.splice(i, 1);
			if (player.shieldActive) {
				// Shield absorbs the hit
				player.shieldActive = false;
				var shield = player.getChildAt(1);
				shield.alpha = 0;
			} else {
				// Reduce player health
				player.health--;
				player.healthBar.updateHealth(player.health);
				// Flash player to indicate damage
				LK.effects.flashObject(player, 0xff0000, 300);
				// Check if player is out of health
				if (player.health <= 0) {
					// Game over
					LK.effects.flashScreen(0xff0000, 1000);
					isGameActive = false;
					LK.showGameOver();
					break;
				}
			}
		}
	}
	// Check enemies colliding with player
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		if (enemy.intersects(player)) {
			if (player.shieldActive) {
				// Shield absorbs the hit
				enemy.destroy();
				enemies.splice(i, 1);
				// Shield gets depleted
				player.shieldActive = false;
				var shield = player.getChildAt(1);
				shield.alpha = 0;
				score += enemy.scoreValue;
				LK.setScore(score);
				updateScoreDisplay();
			} else {
				// Reduce player health by 2 (collision is more dangerous)
				player.health -= 2;
				player.healthBar.updateHealth(player.health);
				// Remove the enemy
				enemy.destroy();
				enemies.splice(i, 1);
				// Flash player to indicate damage
				LK.effects.flashObject(player, 0xff0000, 300);
				// Check if player is out of health
				if (player.health <= 0) {
					// Game over
					LK.effects.flashScreen(0xff0000, 1000);
					isGameActive = false;
					LK.showGameOver();
					break;
				}
			}
		}
	}
	// Check player collecting power-ups
	for (var i = powerUps.length - 1; i >= 0; i--) {
		var powerUp = powerUps[i];
		if (powerUp.intersects(player)) {
			LK.getSound('powerUp').play();
			// Apply power-up effect
			if (powerUp.type === 'shield') {
				player.activateShield();
			} else if (powerUp.type === 'weapon') {
				player.activatePowerUp();
			} else if (powerUp.type === 'quadBullets') {
				player.activateQuadBullets();
			}
			// Remove power-up
			powerUp.destroy();
			powerUps.splice(i, 1);
		}
	}
}
// Clean up off-screen objects
function cleanupOffscreenObjects() {
	// Clean up bullets that went off screen
	for (var i = playerBullets.length - 1; i >= 0; i--) {
		var bullet = playerBullets[i];
		// Check if bullet is off screen based on direction (unless it's bouncing)
		if (!bullet.isBouncing) {
			if (bullet.direction === 'up' && bullet.y < -50 || bullet.direction === 'down' && bullet.y > GAME_HEIGHT + 50 || bullet.direction === 'left' && bullet.x < -50 || bullet.direction === 'right' && bullet.x > GAME_WIDTH + 50) {
				bullet.destroy();
				playerBullets.splice(i, 1);
			}
		} else if (bullet.bounceCount >= bullet.maxBounces) {
			// Remove bouncing bullet that reached max bounce count
			bullet.destroy();
			playerBullets.splice(i, 1);
		}
	}
	for (var i = enemyBullets.length - 1; i >= 0; i--) {
		if (enemyBullets[i].y > GAME_HEIGHT + 50) {
			enemyBullets[i].destroy();
			enemyBullets.splice(i, 1);
		}
	}
	// Clean up enemies that went off screen
	for (var i = enemies.length - 1; i >= 0; i--) {
		if (enemies[i].y > GAME_HEIGHT + 100) {
			enemies[i].destroy();
			enemies.splice(i, 1);
		}
	}
	// Clean up power-ups that went off screen
	for (var i = powerUps.length - 1; i >= 0; i--) {
		if (powerUps[i].y > GAME_HEIGHT + 50) {
			powerUps[i].destroy();
			powerUps.splice(i, 1);
		}
	}
}
// Player movement
var isDragging = false;
game.down = function (x, y) {
	// Set target position
	var targetX = x;
	var targetY = y;
	// Clamp target position to game bounds
	if (targetX < 50) {
		targetX = 50;
	}
	if (targetX > GAME_WIDTH - 50) {
		targetX = GAME_WIDTH - 50;
	}
	if (targetY < 50) {
		targetY = 50;
	}
	if (targetY > GAME_HEIGHT - 50) {
		targetY = GAME_HEIGHT - 50;
	}
	player.targetX = targetX;
	player.targetY = targetY;
	player.isMoving = true;
	// Also shoot when player taps
	playerShoot();
};
game.move = function (x, y) {
	if (isGameActive) {
		// Clamp target position to game bounds
		var targetX = x;
		var targetY = y;
		if (targetX < 50) {
			targetX = 50;
		}
		if (targetX > GAME_WIDTH - 50) {
			targetX = GAME_WIDTH - 50;
		}
		if (targetY < 50) {
			targetY = 50;
		}
		if (targetY > GAME_HEIGHT - 50) {
			targetY = GAME_HEIGHT - 50;
		}
		// Update target position
		player.targetX = targetX;
		player.targetY = targetY;
		// For better tracking during fast mouse movements, directly update position
		player.x = player.targetX;
		player.y = player.targetY;
		player.isMoving = true; //{2K}{2L}{2M}{2N}
	}
};
game.up = function () {
	// Keep the ship moving toward last target point
};
// Main game update loop
game.update = function () {
	if (!isGameActive) {
		return;
	}
	// Spawn enemies
	spawnCounter++;
	var currentSpawnRate = Math.max(SPAWN_ENEMY_INTERVAL - gameLevel * 5, MIN_SPAWN_INTERVAL);
	if (spawnCounter >= currentSpawnRate) {
		spawnEnemy();
		spawnCounter = 0;
	}
	// Spawn power-ups
	powerUpCounter++;
	if (powerUpCounter >= SPAWN_POWERUP_INTERVAL) {
		spawnPowerUp();
		powerUpCounter = 0;
	}
	// Make player shoot automatically
	if (player.isMoving) {
		playerShoot();
	}
	// Update enemy shooting
	for (var i = 0; i < enemies.length; i++) {
		enemyShoot(enemies[i]);
	}
	// Check collisions
	handleCollisions();
	// Clean up off-screen objects
	cleanupOffscreenObjects();
	// Check level progression
	checkLevelProgress();
	// Win condition check
	if (score >= 10000) {
		LK.showYouWin();
		isGameActive = false;
	}
};

===================================================================
--- original.js
+++ change.js
@@ -97,10 +97,10 @@
 });
 var HealthBar = Container.expand(function () {
 	var self = Container.call(this);
 	// Health bar properties
-	self.maxHealth = 5;
-	self.currentHealth = 5;
+	self.maxHealth = 4;
+	self.currentHealth = 4;
 	self.width = 140;
 	self.height = 20;
 	// Create background bar (gray)
 	var background = self.attachAsset('healthbar', {
@@ -212,9 +212,9 @@
 	// Player properties
 	self.speed = 10;
 	self.fireRate = 20; // Ticks between shots
 	self.lastShot = 0;
-	self.health = 5; // Player starts with 5 health
+	self.health = 4; // Player starts with 4 health
 	self.healthBar = new HealthBar();
 	self.healthBar.y = -80; // Position above player
 	self.healthBar.x = 0; // Perfectly center the healthbar with the ship
 	self.addChild(self.healthBar);