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

/**** 
* Classes
****/ 
// --- Bullet Class ---
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	// Attach bullet asset (white ellipse)
	var bulletAsset = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Bullet speed (pixels per frame)
	self.speed = 160;
	// Direction in radians (set on creation)
	self.direction = 0;
	// Damage dealt by this bullet
	self.damage = 1;
	// Defensive: track last position for possible future use
	self.lastX = self.x;
	self.lastY = self.y;
	// Update method called every tick
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		self.x += Math.cos(self.direction) * self.speed;
		self.y += Math.sin(self.direction) * self.speed;
	};
	return self;
});
// --- Enemy Class ---
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	// Attach enemy asset (pink ellipse), scaled up 2x
	var enemyAsset = self.attachAsset('enemyCircle', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2,
		scaleY: 2
	});
	// Enemy properties
	self.radius = 60 + Math.random() * 40; // for spawn distance
	self.speed = 1.15 + Math.random() * 0.55; // even faster approach
	self.maxHp = 3; // always 3 HP
	self.hp = self.maxHp;
	// Direction towards center (set on spawn)
	self.direction = 0;
	// Health bar (white background, green foreground), both rectangles, above the enemy
	self.hpBarBg = self.addChild(LK.getAsset('hpbar_bg', {
		anchorX: 0.5,
		anchorY: 1.0,
		y: -140 // higher above the enemy
	}));
	self.hpBar = self.addChild(LK.getAsset('hpbar_fg', {
		anchorX: 0.5,
		anchorY: 1.0,
		y: -140 // match background bar position
	}));
	// Defensive: track last position for possible future use
	self.lastX = self.x;
	self.lastY = self.y;
	// Update health bar width
	self.updateHpBar = function () {
		// Use asset width for scaling, so health bar always matches background
		self.hpBar.width = self.hpBarBg.width * (self.hp / self.maxHp);
		self.hpBar.x = self.hpBarBg.x - (self.hpBarBg.width - self.hpBar.width) / 2;
	};
	// Update method called every tick
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		self.x += Math.cos(self.direction) * self.speed;
		self.y += Math.sin(self.direction) * self.speed;
	};
	// Take damage
	self.takeDamage = function (amount) {
		self.hp -= amount;
		if (self.hp < 0) self.hp = 0;
		self.updateHpBar();
	};
	// On death
	self.die = function () {
		// Flash effect
		LK.effects.flashObject(self, 0xffffff, 200);
		// Particle explosion (intense red, gravity-free)
		// More and bigger particles, even more red!
		for (var i = 0; i < 38; i++) {
			var p = new Container();
			var asset = p.attachAsset('bullet', {
				anchorX: 0.5,
				anchorY: 0.5,
				// Make particles much bigger overall
				scaleX: 1.1 + Math.random() * 0.8,
				scaleY: 1.1 + Math.random() * 0.8,
				// Use a deeper, more saturated red
				color: 0xff0000,
				alpha: 0.82 + Math.random() * 0.18
			});
			p.x = self.x;
			p.y = self.y;
			var angle = Math.random() * Math.PI * 2;
			var speed = 22 + Math.random() * 20;
			var life = 26 + Math.floor(Math.random() * 18);
			p.update = function (a, s, l) {
				var vx = Math.cos(a) * s;
				var vy = Math.sin(a) * s;
				var ticks = 0;
				return function () {
					this.x += vx;
					this.y += vy;
					vx *= 0.88;
					vy *= 0.88;
					this.alpha *= 0.93;
					ticks++;
					if (ticks > l) {
						this.destroy();
					}
				};
			}(angle, speed, life);
			game.addChild(p);
			// Add to update loop
			if (!game._enemyParticles) game._enemyParticles = [];
			game._enemyParticles.push(p);
		}
	};
	// Initialize health bar
	self.updateHpBar();
	return self;
});
// --- HealthBox Class ---
var HealthBox = Container.expand(function () {
	var self = Container.call(this);
	// Attach health asset (red box), scaled up 1.5x
	var asset = self.attachAsset('healthBox', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.5,
		scaleY: 1.5
	});
	self.radius = 60 + Math.random() * 40;
	self.speed = 0.32 + Math.random() * 0.16; // even faster movement
	self.maxHp = 1;
	self.hp = self.maxHp;
	self.direction = 0;
	// Defensive: track last position
	self.lastX = self.x;
	self.lastY = self.y;
	// Update method
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		self.x += Math.cos(self.direction) * self.speed;
		self.y += Math.sin(self.direction) * self.speed;
	};
	// Take damage
	self.takeDamage = function (amount) {
		self.hp -= amount;
		if (self.hp < 0) self.hp = 0;
	};
	// On death
	self.die = function () {
		LK.effects.flashObject(self, 0xffffff, 200);
		// Particle effect (white explosion)
		for (var i = 0; i < 18; i++) {
			var p = new Container();
			var asset = p.attachAsset('bullet', {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 0.9 + Math.random() * 0.7,
				scaleY: 0.9 + Math.random() * 0.7,
				color: 0xffffff,
				alpha: 0.8 + Math.random() * 0.15
			});
			p.x = self.x;
			p.y = self.y;
			var angle = Math.random() * Math.PI * 2;
			var speed = 12 + Math.random() * 10;
			var life = 16 + Math.floor(Math.random() * 10);
			p.update = function (a, s, l) {
				var vx = Math.cos(a) * s;
				var vy = Math.sin(a) * s;
				var ticks = 0;
				return function () {
					this.x += vx;
					this.y += vy;
					vx *= 0.88;
					vy *= 0.88;
					this.alpha *= 0.91;
					ticks++;
					if (ticks > l) {
						this.destroy();
					}
				};
			}(angle, speed, life);
			game.addChild(p);
			if (!game._enemyParticles) game._enemyParticles = [];
			game._enemyParticles.push(p);
		}
	};
	return self;
});
// --- Player Class ---
var Player = Container.expand(function () {
	var self = Container.call(this);
	// Attach player asset (blue ellipse), scaled up 2x
	var playerAsset = self.attachAsset('character', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2,
		scaleY: 2
	});
	// Player properties
	self.radius = 0; // always at center
	self.rotation = 0; // radians
	self.maxHp = 5;
	self.hp = self.maxHp;
	// Health bar (red background, green foreground) - always on top, not rotating
	self.hpBarBg = LK.getAsset('hpbar_bg', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -140
	});
	self.hpBar = LK.getAsset('hpbar_fg', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -140
	});
	// Defensive: track last position for possible future use
	self.lastX = self.x;
	self.lastY = self.y;
	// Update health bar width
	self.updateHpBar = function () {
		// Use asset width for scaling, so health bar always matches background
		self.hpBar.width = self.hpBarBg.width * (self.hp / self.maxHp);
		self.hpBar.x = self.hpBarBg.x - (self.hpBarBg.width - self.hpBar.width) / 2;
	};
	// Take damage
	self.takeDamage = function (amount) {
		self.hp -= amount;
		if (self.hp < 0) self.hp = 0;
		self.updateHpBar();
	};
	// On death
	self.die = function () {
		LK.effects.flashObject(self, 0xff0000, 500);
	};
	// Initialize health bar
	self.updateHpBar();
	return self;
});
// --- Shield Layer Class ---
var ShieldLayer = Container.expand(function () {
	var self = Container.call(this);
	// Properties
	self.radius = 0; // distance from player center
	self.maxHp = 3;
	self.hp = self.maxHp;
	self.index = 0; // 0=innermost, 2=outermost
	self.active = true;
	// Visual: use ellipse for shield
	self.shieldAsset = self.attachAsset('centerCircle', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.5,
		scaleY: 1.5,
		alpha: 0.25 + 0.15 * self.index // more visible for outer shields
	});
	// Health bar above shield
	self.hpBarBg = self.addChild(LK.getAsset('hpbar_bg', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -self.radius - 120
	}));
	self.hpBar = self.addChild(LK.getAsset('hpbar_fg', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -self.radius - 120
	}));
	// Defensive: track last position for possible future use
	self.lastX = self.x;
	self.lastY = self.y;
	// Update health bar width
	self.updateHpBar = function () {
		// Use asset width for scaling, so health bar always matches background
		self.hpBar.width = self.hpBarBg.width * (self.hp / self.maxHp);
		self.hpBar.x = self.hpBarBg.x - (self.hpBarBg.width - self.hpBar.width) / 2;
		self.hpBar.visible = self.active;
		self.hpBarBg.visible = self.active;
	};
	// Take damage
	self.takeDamage = function (amount) {
		if (!self.active) return;
		self.hp -= amount;
		if (self.hp < 0) self.hp = 0;
		self.updateHpBar();
		if (self.hp <= 0) {
			// Play shield explosion sound
			LK.getSound('shieldExplode').play();
			self.active = false;
			self.visible = false;
			self.hpBar.visible = false;
			self.hpBarBg.visible = false;
		}
	};
	// Reset shield
	self.reset = function () {
		self.hp = self.maxHp;
		self.active = true;
		self.visible = true;
		self.updateHpBar();
	};
	// Initialize
	self.updateHpBar();
	return self;
});

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

/**** 
* Game Code
****/ 
// --- Background Image ---
// Health bar assets for bg/fg
var backgroundImg = LK.getAsset('background', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 2048 / 4096,
	scaleY: 2732 / 4096,
	x: 2048 / 2,
	y: 2732 / 2
});
game.addChild(backgroundImg);
// --- Global Variables --- 
var player;
var enemies = [];
var bullets = [];
var spawnTimer = 0;
var fireCooldown = 0;
var dragActive = false;
var lastTouchAngle = 0;
// --- Score Display ---
var scoreTxt = new Text2('0', {
	size: 120,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// --- Player Initialization --- 
player = new Player();
player.x = 2048 / 2;
player.y = 2732 / 2;
game.addChild(player);
// Add player health bar to game (not as child of player, so it doesn't rotate)
game.addChild(player.hpBarBg);
game.addChild(player.hpBar);
// Position health bar above player
player.hpBarBg.x = player.x;
player.hpBarBg.y = player.y - 160;
player.hpBar.x = player.x;
player.hpBar.y = player.y - 160;
// --- Shield Layers Initialization ---
var shieldLayers = [];
var shieldRadii = [180 * 1.5, 260 * 1.5, 340 * 1.5]; // innermost to outermost, 1.5x larger
for (var i = 0; i < 3; i++) {
	var shield = new ShieldLayer();
	shield.index = i;
	shield.radius = shieldRadii[i];
	// Scale shield asset to match radius
	var asset = shield.shieldAsset;
	var baseSize = asset.width; // asset is 100x100
	var scale = shield.radius * 2 / baseSize;
	asset.scaleX = scale;
	asset.scaleY = scale;
	// Position shield at player center
	shield.x = player.x;
	shield.y = player.y;
	// Defensive: initialize lastX/lastY
	shield.lastX = shield.x;
	shield.lastY = shield.y;
	// Move health bar above shield
	shield.hpBarBg.y = -shield.radius - 120;
	shield.hpBar.y = -shield.radius - 120;
	game.addChild(shield);
	shieldLayers.push(shield);
}
// --- Helper: Get angle from center to (x, y) ---
function getAngleToCenter(x, y) {
	var cx = 2048 / 2;
	var cy = 2732 / 2;
	return Math.atan2(y - cy, x - cx);
}
// --- Helper: Fire Bullet ---
function fireBullet(angle) {
	if (fireCooldown > 0) return;
	var bullet = new Bullet();
	bullet.x = player.x;
	bullet.y = player.y;
	bullet.direction = angle;
	// Defensive: initialize lastX/lastY
	bullet.lastX = bullet.x;
	bullet.lastY = bullet.y;
	bullets.push(bullet);
	game.addChild(bullet);
	fireCooldown = 10; // frames
	// Play shoot sound
	LK.getSound('shoot').play();
}
// --- Handle Touch/Drag to Rotate Player ---
game.down = function (x, y, obj) {
	dragActive = true;
	var angle = getAngleToCenter(x, y);
	lastTouchAngle = angle;
	// Instantly rotate player to this angle
	player.rotation = angle;
};
game.move = function (x, y, obj) {
	if (dragActive) {
		var angle = getAngleToCenter(x, y);
		player.rotation = angle;
		lastTouchAngle = angle;
	}
};
game.up = function (x, y, obj) {
	dragActive = false;
	// Fire bullet in the direction player is facing
	fireBullet(player.rotation);
	// After firing, reset player rotation to upright (0 radians)
	player.rotation = 0;
};
// --- Enemy Spawning ---
function spawnEnemy() {
	var angle = Math.random() * Math.PI * 2;
	var distance = 1100 + Math.random() * 400;
	var ex = 2048 / 2 + Math.cos(angle) * distance;
	var ey = 2732 / 2 + Math.sin(angle) * distance;
	// 1 in 5 chance to spawn a health box instead of enemy (increased frequency)
	if (Math.random() < 0.2) {
		var healthBox = new HealthBox();
		healthBox.x = ex;
		healthBox.y = ey;
		healthBox.direction = Math.atan2(2732 / 2 - ey, 2048 / 2 - ex);
		healthBox.lastX = healthBox.x;
		healthBox.lastY = healthBox.y;
		enemies.push(healthBox);
		game.addChild(healthBox);
	} else {
		var enemy = new Enemy();
		enemy.x = ex;
		enemy.y = ey;
		// Set direction towards player center
		enemy.direction = Math.atan2(2732 / 2 - ey, 2048 / 2 - ex);
		// Scale enemy speed with score: base speed + (score * 0.08), capped at 7x base
		var score = LK.getScore();
		var speedScale = 1 + Math.min(score * 0.08, 6); // up to 7x base speed
		enemy.speed *= speedScale;
		// Defensive: initialize lastX/lastY
		enemy.lastX = enemy.x;
		enemy.lastY = enemy.y;
		enemies.push(enemy);
		game.addChild(enemy);
	}
}
// --- Game Update Loop ---
game.update = function () {
	// --- Fire cooldown ---
	if (fireCooldown > 0) fireCooldown--;
	// Keep player health bar above player (not rotating)
	player.hpBarBg.x = player.x;
	player.hpBarBg.y = player.y - 120;
	player.hpBar.x = player.x;
	player.hpBar.y = player.y - 120;
	// --- Enemy spawn timer ---
	spawnTimer--;
	if (spawnTimer <= 0) {
		spawnEnemy();
		// Make enemies and health boxes spawn less frequently (every 2.5-3.5s)
		spawnTimer = 150 + Math.floor(Math.random() * 60); // spawn every 2.5-3.5s
	}
	// --- Update Bullets ---
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		// Defensive: initialize lastX/lastY if not set
		if (typeof bullet.lastX === "undefined") bullet.lastX = bullet.x;
		if (typeof bullet.lastY === "undefined") bullet.lastY = bullet.y;
		bullet.update();
		// Remove if out of bounds
		if (bullet.x < -200 || bullet.x > 2048 + 200 || bullet.y < -200 || bullet.y > 2732 + 200) {
			bullet.destroy();
			bullets.splice(i, 1);
			continue;
		}
		// Check collision with enemies
		var hit = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			// Defensive: initialize lastX/lastY if not set
			if (typeof enemy.lastX === "undefined") enemy.lastX = enemy.x;
			if (typeof enemy.lastY === "undefined") enemy.lastY = enemy.y;
			if (bullet.intersects(enemy)) {
				// HealthBox dies in 1 hit, Enemy dies at 0 hp
				var isHealthBox = typeof enemy.maxHp !== "undefined" && enemy.maxHp === 1;
				if (isHealthBox) {
					// HealthBox: always die in one hit, regardless of hp
					enemy.hp = 0;
				} else {
					enemy.takeDamage(bullet.damage);
				}
				if (enemy.hp <= 0) {
					var isHealthBox = typeof enemy.maxHp !== "undefined" && enemy.maxHp === 1;
					if (isHealthBox) {
						// HealthBox: if any shield is missing (inactive), revive it (starting from innermost)
						var revived = false;
						for (var ss = 0; ss < shieldLayers.length; ss++) {
							if (!shieldLayers[ss].active) {
								shieldLayers[ss].reset();
								revived = true;
								// Flash revived shield
								LK.effects.flashObject(shieldLayers[ss], 0x44ff44, 400);
								break;
							}
						}
						// If all shields are active, fully restore outermost shield
						if (!revived && shieldLayers.length > 0) {
							var outermost = shieldLayers[shieldLayers.length - 1];
							outermost.hp = outermost.maxHp;
							outermost.updateHpBar();
							LK.effects.flashObject(outermost, 0x44ff44, 400);
						}
						// Play a positive effect on shield
						LK.getSound('shieldHit').play();
					} else {
						LK.getSound('enemyDie').play();
					}
					enemy.die();
					enemy.destroy();
					enemies.splice(j, 1);
					if (!(typeof enemy.maxHp !== "undefined" && enemy.maxHp === 1)) {
						LK.setScore(LK.getScore() + 1);
						scoreTxt.setText(LK.getScore());
					}
				}
				bullet.destroy();
				bullets.splice(i, 1);
				hit = true;
				break;
			}
		}
		if (hit) continue;
	}
	// --- Update Enemies ---
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		// Defensive: initialize lastX/lastY if not set
		if (typeof enemy.lastX === "undefined") enemy.lastX = enemy.x;
		if (typeof enemy.lastY === "undefined") enemy.lastY = enemy.y;
		enemy.update();
		// Check collision with shields (outermost to innermost)
		var blocked = false;
		for (var s = shieldLayers.length - 1; s >= 0; s--) {
			var shield = shieldLayers[s];
			if (shield.active) {
				// Defensive: initialize lastX/lastY if not set
				if (typeof shield.lastX === "undefined") shield.lastX = shield.x;
				if (typeof shield.lastY === "undefined") shield.lastY = shield.y;
				// Check distance from player center to enemy center
				var dx = enemy.x - player.x;
				var dy = enemy.y - player.y;
				var dist = Math.sqrt(dx * dx + dy * dy);
				// Enemy "radius" is ~50, shield is at shield.radius (already 1.5x larger)
				if (dist < shield.radius + 50) {
					// Collided with shield
					var isHealthBox = typeof enemy.maxHp !== "undefined" && enemy.maxHp === 1;
					if (isHealthBox) {
						// HealthBox: just disappears, does not affect shield, no revive or restore
						enemy.die();
						enemy.destroy();
						enemies.splice(i, 1);
						blocked = true;
						break;
					} else {
						// Regular enemy: damage shield
						shield.takeDamage(1);
						LK.getSound('shieldHit').play();
						enemy.die();
						enemy.destroy();
						enemies.splice(i, 1);
						// Increase score when enemy dies by hitting shield
						LK.setScore(LK.getScore() + 1);
						scoreTxt.setText(LK.getScore());
						// Flash shield
						LK.effects.flashObject(shield, 0x44aaff, 200);
						blocked = true;
						break;
					}
				}
			}
		}
		if (blocked) continue;
		// If not blocked, check collision with player
		if (enemy.intersects(player)) {
			player.takeDamage(1);
			LK.getSound('enemyDie').play();
			enemy.die();
			enemy.destroy();
			enemies.splice(i, 1);
			// Flash screen
			LK.effects.flashScreen(0xff0000, 400);
			// Game over if player dead
			if (player.hp <= 0) {
				player.die();
				LK.showGameOver();
				return;
			}
		}
	}
	;
	// --- Update and cleanup enemy death particles ---
	if (game._enemyParticles) {
		for (var i = game._enemyParticles.length - 1; i >= 0; i--) {
			var p = game._enemyParticles[i];
			// Defensive: initialize lastX/lastY if not set
			if (typeof p.lastX === "undefined") p.lastX = p.x;
			if (typeof p.lastY === "undefined") p.lastY = p.y;
			if (p.destroyed) {
				game._enemyParticles.splice(i, 1);
				continue;
			}
			if (typeof p.update === "function") p.update();
		}
	}
};
// --- Score Initialization ---
LK.setScore(0);
scoreTxt.setText(LK.getScore());

===================================================================
--- original.js
+++ change.js
@@ -592,8 +592,11 @@
 						LK.getSound('shieldHit').play();
 						enemy.die();
 						enemy.destroy();
 						enemies.splice(i, 1);
+						// Increase score when enemy dies by hitting shield
+						LK.setScore(LK.getScore() + 1);
+						scoreTxt.setText(LK.getScore());
 						// Flash shield
 						LK.effects.flashObject(shield, 0x44aaff, 200);
 						blocked = true;
 						break;