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

/**** 
* Classes
****/ 
var BeatIndicator = Container.expand(function () {
	var self = Container.call(this);
	var indicatorGraphics = self.attachAsset('beatIndicator', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	indicatorGraphics.alpha = 0.3;
	self.pulse = function () {
		indicatorGraphics.alpha = 0.8;
		tween(indicatorGraphics, {
			alpha: 0.3,
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				indicatorGraphics.scaleX = 1;
				indicatorGraphics.scaleY = 1;
			}
		});
	};
	return self;
});
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 25;
	self.directionX = 0;
	self.directionY = -1;
	self.enemiesKilled = 0;
	self.maxKills = 2;
	self.bounceCount = 0;
	self.maxBounces = 3;
	self.update = function () {
		// Store previous position for collision detection
		if (self.lastX === undefined) self.lastX = self.x;
		if (self.lastY === undefined) self.lastY = self.y;
		self.x += self.directionX * self.speed;
		self.y += self.directionY * self.speed;
		// Check wall collisions and bounce
		if (self.x <= 10 && self.directionX < 0) {
			self.directionX = -self.directionX; // Bounce off left wall
			self.x = 10;
			self.bounceCount++;
		}
		if (self.x >= 2038 && self.directionX > 0) {
			self.directionX = -self.directionX; // Bounce off right wall
			self.x = 2038;
			self.bounceCount++;
		}
		if (self.y <= 10 && self.directionY < 0) {
			self.directionY = -self.directionY; // Bounce off top wall
			self.y = 10;
			self.bounceCount++;
		}
		if (self.y >= 2722 && self.directionY > 0) {
			self.directionY = -self.directionY; // Bounce off bottom wall
			self.y = 2722;
			self.bounceCount++;
		}
		// Update last positions
		self.lastX = self.x;
		self.lastY = self.y;
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.targetX = self.x;
	self.targetY = self.y;
	self.moveSpeed = 0.1;
	self.isMoving = false;
	self.setTarget = function (x, y) {
		self.targetX = x;
		self.targetY = y;
		self.isMoving = true;
		tween(self, {
			x: x,
			y: y
		}, {
			duration: 800,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isMoving = false;
			}
		});
	};
	return self;
});
var GiantEnemy = Container.expand(function () {
	var self = Container.call(this);
	var giantGraphics = self.attachAsset('giantEnemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 5;
	self.speed = 2;
	self.update = function () {
		// Move toward player
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.canShoot = true;
	self.shootCooldown = 0;
	return self;
});
var PredictionCircle = Container.expand(function () {
	var self = Container.call(this);
	var circleGraphics = self.attachAsset('predictionCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	circleGraphics.alpha = 0.7;
	self.show = function () {
		// Make circle visible and animate it
		circleGraphics.alpha = 0.7;
		circleGraphics.scaleX = 0.5;
		circleGraphics.scaleY = 0.5;
		// Animate appearance
		tween(circleGraphics, {
			scaleX: 1,
			scaleY: 1,
			alpha: 0.9
		}, {
			duration: 200,
			easing: tween.easeOut
		});
		// Auto-hide after 2 seconds
		tween(circleGraphics, {
			alpha: 0,
			scaleX: 0.5,
			scaleY: 0.5
		}, {
			duration: 300,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var player;
var enemies = [];
var bullets = [];
var predictionCircles = [];
var beatIndicator;
var beatTimer = 0;
var beatInterval = 300; // 5 seconds at 60fps
var nextBeatTime = 0;
var canShootWindow = false;
var shootWindow = 60; // 1 second window after beat
var shootWindowTimer = 0;
var totalKills = 0;
var bulletsPerShot = 1;
var enemyPositions = [{
	x: 400,
	y: 300
}, {
	x: 1648,
	y: 300
}, {
	x: 1024,
	y: 200
}, {
	x: 600,
	y: 500
}, {
	x: 1448,
	y: 500
}];
var currentWave = 0;
var enemyPredictionTimer = 0;
var enemyPredictionInterval = 180; // 3 seconds at 60fps
var giantEnemies = [];
var giantEnemyTimer = 0;
var giantEnemyInterval = 3600; // 60 seconds at 60fps (1 minute)
// UI elements
var scoreTxt = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
var beatCounterTxt = new Text2('Next Beat: 5.0s', {
	size: 50,
	fill: 0x00FF00
});
beatCounterTxt.anchor.set(0.5, 0);
beatCounterTxt.y = 80;
LK.gui.top.addChild(beatCounterTxt);
var shootStatusTxt = new Text2('', {
	size: 45,
	fill: 0xFFFF00
});
shootStatusTxt.anchor.set(0.5, 0);
shootStatusTxt.y = 140;
LK.gui.top.addChild(shootStatusTxt);
var enemyPredictionTxt = new Text2('', {
	size: 40,
	fill: 0xff9800
});
enemyPredictionTxt.anchor.set(0.5, 0);
enemyPredictionTxt.y = 190;
LK.gui.top.addChild(enemyPredictionTxt);
var bossCountdownTxt = new Text2('Next Boss: 60.0s', {
	size: 45,
	fill: 0xff0000
});
bossCountdownTxt.anchor.set(0.5, 0);
bossCountdownTxt.y = 240;
LK.gui.top.addChild(bossCountdownTxt);
// Player health system
var playerHealth = 3;
var maxPlayerHealth = 3;
var playerHealthTxt = new Text2('Lives: 3/3', {
	size: 45,
	fill: 0x00ff00
});
playerHealthTxt.anchor.set(0.5, 0);
playerHealthTxt.y = 290;
LK.gui.top.addChild(playerHealthTxt);
// Initialize player
player = game.addChild(new Player());
player.x = 1024;
player.y = 2400;
// Initialize beat indicator
beatIndicator = game.addChild(new BeatIndicator());
beatIndicator.x = 1024;
beatIndicator.y = 1366;
// Initialize enemies
function spawnEnemies() {
	// Clear existing enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		enemies[i].destroy();
		enemies.splice(i, 1);
	}
	// Clear any remaining prediction circles
	for (var c = predictionCircles.length - 1; c >= 0; c--) {
		predictionCircles[c].destroy();
		predictionCircles.splice(c, 1);
	}
	// Spawn new enemies - base amount plus bonus based on total kills
	var baseEnemies = 3 + Math.floor(currentWave / 2);
	var bonusEnemies = Math.floor(totalKills / 5); // 1 extra enemy per 5 kills
	var numEnemies = Math.min(baseEnemies + bonusEnemies, 5);
	for (var i = 0; i < numEnemies; i++) {
		var enemy = game.addChild(new Enemy());
		var pos = enemyPositions[i % enemyPositions.length];
		enemy.x = pos.x;
		enemy.y = pos.y;
		enemies.push(enemy);
	}
}
function moveEnemies() {
	for (var i = 0; i < enemies.length; i++) {
		var enemy = enemies[i];
		var newPos = enemyPositions[(enemies.indexOf(enemy) + currentWave + 1) % enemyPositions.length];
		enemy.setTarget(newPos.x, newPos.y);
	}
}
function createBullet(targetX, targetY) {
	// Update bullets per shot based on total kills
	bulletsPerShot = 1 + Math.floor(totalKills / 3); // 1 extra bullet per 3 kills
	bulletsPerShot = Math.min(bulletsPerShot, 5); // Cap at 5 bullets
	// Create multiple bullets
	for (var b = 0; b < bulletsPerShot; b++) {
		var bullet = game.addChild(new Bullet());
		// Calculate direction to target first
		var dx = targetX - player.x;
		var dy = targetY - player.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Add spread for multiple bullets
		var spreadAngle = 0;
		if (bulletsPerShot > 1) {
			var maxSpread = Math.PI / 6; // 30 degrees total spread
			spreadAngle = (b - (bulletsPerShot - 1) / 2) * (maxSpread / (bulletsPerShot - 1));
		}
		if (distance > 0) {
			var baseDirectionX = dx / distance;
			var baseDirectionY = dy / distance;
			// Apply spread rotation
			bullet.directionX = baseDirectionX * Math.cos(spreadAngle) - baseDirectionY * Math.sin(spreadAngle);
			bullet.directionY = baseDirectionX * Math.sin(spreadAngle) + baseDirectionY * Math.cos(spreadAngle);
		}
		// Position bullet in front of player (offset by player size + bullet size to avoid collision)
		var offsetDistance = 80; // Player size (70) + bullet height (40) + small buffer
		bullet.x = player.x + bullet.directionX * offsetDistance;
		bullet.y = player.y + bullet.directionY * offsetDistance;
		bullets.push(bullet);
	}
	LK.getSound('shoot').play();
}
function damagePlayer() {
	playerHealth--;
	playerHealthTxt.setText('Lives: ' + playerHealth + '/' + maxPlayerHealth);
	// Flash player red when damaged
	LK.effects.flashObject(player, 0xff0000, 500);
	// Update health text color based on remaining health
	if (playerHealth <= 1) {
		playerHealthTxt.fill = 0xff0000; // Red when critical
	} else if (playerHealth <= 2) {
		playerHealthTxt.fill = 0xffa500; // Orange when low
	}
	// Check if player is dead
	if (playerHealth <= 0) {
		LK.effects.flashScreen(0xff0000, 1000);
		LK.showGameOver();
		return true; // Player is dead
	}
	return false; // Player is still alive
}
// Touch/click handling
game.down = function (x, y, obj) {
	if (canShootWindow) {
		createBullet(x, y);
	}
};
// Initialize game
spawnEnemies();
nextBeatTime = beatInterval;
// Start background music
LK.playMusic('musicabg3');
// Main game update loop
game.update = function () {
	beatTimer++;
	giantEnemyTimer++;
	// Giant enemy spawn system
	if (giantEnemyTimer >= giantEnemyInterval) {
		// Spawn giant enemy at random edge of screen
		var giantEnemy = game.addChild(new GiantEnemy());
		var side = Math.floor(Math.random() * 4); // 0=top, 1=right, 2=bottom, 3=left
		if (side === 0) {
			// top
			giantEnemy.x = Math.random() * 2048;
			giantEnemy.y = 0;
		} else if (side === 1) {
			// right
			giantEnemy.x = 2048;
			giantEnemy.y = Math.random() * 2732;
		} else if (side === 2) {
			// bottom
			giantEnemy.x = Math.random() * 2048;
			giantEnemy.y = 2732;
		} else {
			// left
			giantEnemy.x = 0;
			giantEnemy.y = Math.random() * 2732;
		}
		giantEnemies.push(giantEnemy);
		giantEnemyTimer = 0;
	}
	// Beat system
	if (beatTimer >= nextBeatTime) {
		// Beat occurred
		beatIndicator.pulse();
		LK.getSound('beat').play();
		// Move enemies
		moveEnemies();
		currentWave++;
		// Enable shooting window
		canShootWindow = true;
		shootWindowTimer = 0;
		// Reset beat timer
		beatTimer = 0;
		nextBeatTime = beatInterval;
	}
	// Shooting window management
	if (canShootWindow) {
		shootWindowTimer++;
		if (shootWindowTimer >= shootWindow) {
			canShootWindow = false;
		}
	}
	// Update UI
	var timeToNextBeat = (nextBeatTime - beatTimer) / 60.0;
	beatCounterTxt.setText('Next Beat: ' + timeToNextBeat.toFixed(1) + 's');
	if (canShootWindow) {
		var windowTimeLeft = (shootWindow - shootWindowTimer) / 60.0;
		shootStatusTxt.setText('SHOOT NOW! (' + windowTimeLeft.toFixed(1) + 's)');
	} else {
		shootStatusTxt.setText('Wait for beat...');
	}
	// Update boss countdown
	var timeToNextBoss = (giantEnemyInterval - giantEnemyTimer) / 60.0;
	bossCountdownTxt.setText('Next Boss: ' + timeToNextBoss.toFixed(1) + 's');
	// Enemy movement prediction system
	enemyPredictionTimer++;
	if (enemyPredictionTimer >= enemyPredictionInterval) {
		// Clear existing prediction circles
		for (var c = predictionCircles.length - 1; c >= 0; c--) {
			predictionCircles[c].destroy();
			predictionCircles.splice(c, 1);
		}
		// Announce where enemies will move
		var nextPositions = [];
		for (var k = 0; k < enemies.length; k++) {
			var enemy = enemies[k];
			var nextPosIndex = (enemies.indexOf(enemy) + currentWave + 1) % enemyPositions.length;
			var nextPos = enemyPositions[nextPosIndex];
			nextPositions.push('(' + Math.floor(nextPos.x) + ',' + Math.floor(nextPos.y) + ')');
			// Create prediction circle at the target position
			var predictionCircle = game.addChild(new PredictionCircle());
			predictionCircle.x = nextPos.x;
			predictionCircle.y = nextPos.y;
			predictionCircles.push(predictionCircle);
			predictionCircle.show();
		}
		if (nextPositions.length > 0) {
			enemyPredictionTxt.setText('Enemies moving to: ' + nextPositions.join(', '));
		}
		enemyPredictionTimer = 0;
	}
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		// Check if bullet has bounced too many times
		if (bullet.bounceCount >= bullet.maxBounces) {
			bullet.destroy();
			bullets.splice(i, 1);
			continue;
		}
		// Check bullet-player collision (player loses if hit by own bullet)
		if (bullet.intersects(player)) {
			// Damage player and remove bullet
			if (damagePlayer()) {
				return; // Player died, exit update loop
			}
			bullet.destroy();
			bullets.splice(i, 1);
			continue;
		}
		// Remove off-screen check since bullets now bounce
		// Check bullet-enemy collisions
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (bullet.intersects(enemy)) {
				// Hit!
				totalKills++;
				bullet.enemiesKilled++;
				LK.setScore(LK.getScore() + 100);
				scoreTxt.setText('Score: ' + LK.getScore() + ' | Kills: ' + totalKills + ' | Bullets: ' + bulletsPerShot);
				LK.getSound('hit').play();
				LK.effects.flashObject(enemy, 0xffffff, 200);
				// Remove enemy
				enemy.destroy();
				enemies.splice(j, 1);
				// Only remove bullet if it has killed maximum enemies
				if (bullet.enemiesKilled >= bullet.maxKills) {
					bullet.destroy();
					bullets.splice(i, 1);
				}
				break;
			}
		}
		// Check bullet-giant enemy collisions
		for (var g = giantEnemies.length - 1; g >= 0; g--) {
			var giantEnemy = giantEnemies[g];
			if (bullet.intersects(giantEnemy)) {
				// Hit giant enemy
				giantEnemy.health--;
				bullet.enemiesKilled++;
				LK.setScore(LK.getScore() + 50);
				scoreTxt.setText('Score: ' + LK.getScore() + ' | Kills: ' + totalKills + ' | Bullets: ' + bulletsPerShot);
				LK.getSound('hit').play();
				LK.effects.flashObject(giantEnemy, 0xffffff, 200);
				// Check if giant enemy is defeated
				if (giantEnemy.health <= 0) {
					totalKills++;
					giantEnemy.destroy();
					giantEnemies.splice(g, 1);
				}
				// Only remove bullet if it has killed maximum enemies
				if (bullet.enemiesKilled >= bullet.maxKills) {
					bullet.destroy();
					bullets.splice(i, 1);
				}
				break;
			}
		}
	}
	// Check giant enemy-player collisions
	for (var g = 0; g < giantEnemies.length; g++) {
		var giantEnemy = giantEnemies[g];
		if (giantEnemy.intersects(player)) {
			// Add collision tracking to prevent multiple hits per frame
			if (giantEnemy.lastPlayerHit === undefined) giantEnemy.lastPlayerHit = false;
			if (!giantEnemy.lastPlayerHit) {
				giantEnemy.lastPlayerHit = true;
				if (damagePlayer()) {
					return; // Player died, exit update loop
				}
			}
		} else {
			giantEnemy.lastPlayerHit = false;
		}
	}
	// Check win condition - player wins at 10,000 points
	if (LK.getScore() >= 10000) {
		LK.showYouWin();
	}
	// Spawn new enemies if all are destroyed
	if (enemies.length === 0) {
		spawnEnemies();
	}
};

===================================================================
--- original.js
+++ change.js