/**** 
* 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 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
// 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);
// 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();
}
// Touch/click handling
game.down = function (x, y, obj) {
	if (canShootWindow) {
		createBullet(x, y);
	}
};
// Initialize game
spawnEnemies();
nextBeatTime = beatInterval;
// Start background music
LK.playMusic('bgmusic');
// Main game update loop
game.update = function () {
	beatTimer++;
	// 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...');
	}
	// 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)) {
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
			return;
		}
		// 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 win condition
	if (enemies.length === 0 && currentWave >= 10) {
		LK.showYouWin();
	}
	// Spawn new enemies if all are destroyed
	if (enemies.length === 0) {
		spawnEnemies();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -112,8 +112,44 @@
 	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
 ****/ 
@@ -127,8 +163,9 @@
 // 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;
@@ -198,8 +235,13 @@
 	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);
@@ -297,15 +339,26 @@
 	}
 	// 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(', '));
 		}