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

/**** 
* Classes
****/ 
var BloodSplat = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('blood', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.lifetime = 300; // 5 seconds at 60fps
	self.fadeStartTime = 0;
	self.isFading = false;
	self.update = function () {
		self.lifetime--;
		// Start fading after 10 seconds
		if (self.lifetime <= 0 && !self.isFading) {
			self.isFading = true;
			tween(graphics, {
				alpha: 0
			}, {
				duration: 3000,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
		}
	};
	return self;
});
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 20;
	self.dx = 0;
	self.dy = 0;
	self.active = true;
	self.bounced = false;
	self.update = function () {
		if (!self.active) return;
		self.x += self.dx;
		self.y += self.dy;
		if (self.x < -50 || self.x > 2098 || self.y < -50 || self.y > 2782) {
			self.active = false;
		}
	};
	self.setDirection = function (targetX, targetY) {
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.dx = dx / distance * self.speed;
			self.dy = dy / distance * self.speed;
			// Rotate bullet to face direction of travel
			graphics.rotation = Math.atan2(dy, dx) + Math.PI / 2;
		}
	};
	self.bounce = function (hitMonster) {
		if (self.bounced || activePowers.indexOf('bouncy') === -1) return;
		// Find nearest monster regardless of distance
		var nearestMonster = null;
		var nearestDistance = Infinity; // No distance limit
		for (var i = 0; i < monsters.length; i++) {
			var monster = monsters[i];
			if (!monster.active || monster === hitMonster) continue;
			var dx = monster.x - self.x;
			var dy = monster.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < nearestDistance) {
				nearestDistance = distance;
				nearestMonster = monster;
			}
		}
		if (nearestMonster) {
			self.bounced = true;
			self.bounceTarget = nearestMonster; // Store the target
			self.setDirection(nearestMonster.x, nearestMonster.y);
			graphics.tint = 0x00FF00; // Green tint for bounced bullets
		} else {
			// No target found, deactivate bullet
			self.active = false;
		}
	};
	return self;
});
var Card = Container.expand(function (powerType) {
	var self = Container.call(this);
	// Card background
	var cardBg = LK.getAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2,
		scaleY: 1.5
	});
	cardBg.tint = 0x2c3e50;
	self.addChild(cardBg);
	// Card title text
	var titleText = new Text2(getPowerTitle(powerType), {
		size: 50,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.y = -40;
	self.addChild(titleText);
	// Card description text
	var descText = new Text2(getPowerDescription(powerType), {
		size: 30,
		fill: 0xECF0F1
	});
	descText.anchor.set(0.5, 0.5);
	descText.y = 20;
	self.addChild(descText);
	self.powerType = powerType;
	// Card selection handler
	self.down = function (x, y, obj) {
		selectCard(self.powerType);
	};
	return self;
});
var FastZombie = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('fastZombie', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 4; // Faster than normal zombie (2)
	self.health = 1;
	self.damage = 10;
	self.active = true;
	self.lastPlayerDistance = 0;
	self.update = function () {
		if (!self.active) return;
		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;
			// Rotate monster to face the player
			graphics.rotation = Math.atan2(dy, dx) + Math.PI / 2;
		}
		var currentDistance = distance;
		if (self.lastPlayerDistance > 50 && currentDistance <= 50) {
			player.takeDamage(self.damage);
			self.active = false;
		}
		self.lastPlayerDistance = currentDistance;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.active = false;
			// Create blood explosion with spreading effect
			for (var i = 0; i < 15; i++) {
				var bloodSplat = new BloodSplat();
				// Start at monster position
				bloodSplat.x = self.x;
				bloodSplat.y = self.y;
				bloodSplat.graphics = bloodSplat.children[0];
				var scale = 0.3 + Math.random() * 1.2;
				bloodSplat.graphics.scaleX = scale;
				bloodSplat.graphics.scaleY = scale;
				// Calculate random spread destination
				var angle = Math.random() * Math.PI * 2;
				var distance = 150 + Math.random() * 300;
				var targetX = self.x + Math.cos(angle) * distance;
				var targetY = self.y + Math.sin(angle) * distance;
				// Keep within game bounds
				targetX = Math.max(50, Math.min(1998, targetX));
				targetY = Math.max(50, Math.min(2682, targetY));
				// Animate spreading with random delay and duration
				var delay = Math.random() * 200;
				var duration = 300 + Math.random() * 400;
				tween(bloodSplat, {
					x: targetX,
					y: targetY
				}, {
					duration: duration,
					easing: tween.easeOut
				});
				bloodSplats.push(bloodSplat);
				game.addChild(bloodSplat);
			}
			LK.setScore(LK.getScore() + 10);
			LK.getSound('hit').play();
			return true;
		}
		return false;
	};
	return self;
});
var Monster = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('monster', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 2;
	self.health = 1;
	self.damage = 10;
	self.active = true;
	self.lastPlayerDistance = 0;
	self.update = function () {
		if (!self.active) return;
		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;
			// Rotate monster to face the player
			graphics.rotation = Math.atan2(dy, dx) + Math.PI / 2;
		}
		var currentDistance = distance;
		if (self.lastPlayerDistance > 50 && currentDistance <= 50) {
			player.takeDamage(self.damage);
			self.active = false;
		}
		self.lastPlayerDistance = currentDistance;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.active = false;
			// Create blood explosion with spreading effect
			for (var i = 0; i < 15; i++) {
				var bloodSplat = new BloodSplat();
				// Start at monster position
				bloodSplat.x = self.x;
				bloodSplat.y = self.y;
				bloodSplat.graphics = bloodSplat.children[0];
				var scale = 0.3 + Math.random() * 1.2;
				bloodSplat.graphics.scaleX = scale;
				bloodSplat.graphics.scaleY = scale;
				// Calculate random spread destination
				var angle = Math.random() * Math.PI * 2;
				var distance = 150 + Math.random() * 300;
				var targetX = self.x + Math.cos(angle) * distance;
				var targetY = self.y + Math.sin(angle) * distance;
				// Keep within game bounds
				targetX = Math.max(50, Math.min(1998, targetX));
				targetY = Math.max(50, Math.min(2682, targetY));
				// Animate spreading with random delay and duration
				var delay = Math.random() * 200;
				var duration = 300 + Math.random() * 400;
				tween(bloodSplat, {
					x: targetX,
					y: targetY
				}, {
					duration: duration,
					easing: tween.easeOut
				});
				bloodSplats.push(bloodSplat);
				game.addChild(bloodSplat);
			}
			LK.setScore(LK.getScore() + 10);
			LK.getSound('hit').play();
			return true;
		}
		return false;
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 100;
	self.maxHealth = 100;
	self.fireRate = 8;
	self.fireTimer = 0;
	self.update = function () {
		if (self.fireTimer > 0) {
			self.fireTimer--;
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.health = 0;
			LK.showGameOver();
		}
		LK.effects.flashObject(self, 0xff0000, 300);
	};
	self.canFire = function () {
		return self.fireTimer <= 0;
	};
	self.fire = function () {
		if (self.canFire()) {
			self.fireTimer = self.fireRate;
			return true;
		}
		return false;
	};
	return self;
});
var ToughZombie = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('toughZombie', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 1.5; // Slower than normal zombie
	self.health = 2; // Much tougher
	self.damage = 15; // Higher damage
	self.active = true;
	self.lastPlayerDistance = 0;
	self.update = function () {
		if (!self.active) return;
		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;
			// Rotate monster to face the player
			graphics.rotation = Math.atan2(dy, dx) + Math.PI / 2;
		}
		var currentDistance = distance;
		if (self.lastPlayerDistance > 50 && currentDistance <= 50) {
			player.takeDamage(self.damage);
			self.active = false;
		}
		self.lastPlayerDistance = currentDistance;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.active = false;
			// Create blood explosion with spreading effect
			for (var i = 0; i < 15; i++) {
				var bloodSplat = new BloodSplat();
				// Start at monster position
				bloodSplat.x = self.x;
				bloodSplat.y = self.y;
				bloodSplat.graphics = bloodSplat.children[0];
				var scale = 0.3 + Math.random() * 1.2;
				bloodSplat.graphics.scaleX = scale;
				bloodSplat.graphics.scaleY = scale;
				// Calculate random spread destination
				var angle = Math.random() * Math.PI * 2;
				var distance = 150 + Math.random() * 300;
				var targetX = self.x + Math.cos(angle) * distance;
				var targetY = self.y + Math.sin(angle) * distance;
				// Keep within game bounds
				targetX = Math.max(50, Math.min(1998, targetX));
				targetY = Math.max(50, Math.min(2682, targetY));
				// Animate spreading with random delay and duration
				var delay = Math.random() * 200;
				var duration = 300 + Math.random() * 400;
				tween(bloodSplat, {
					x: targetX,
					y: targetY
				}, {
					duration: duration,
					easing: tween.easeOut
				});
				bloodSplats.push(bloodSplat);
				game.addChild(bloodSplat);
			}
			LK.setScore(LK.getScore() + 20); // Higher score for tough zombie
			LK.getSound('hit').play();
			return true;
		}
		return false;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var player = null;
var bullets = [];
var monsters = [];
var bloodSplats = [];
var waveNumber = 1;
var monstersInWave = 5;
var monstersSpawned = 0;
var monstersKilled = 0;
var spawnTimer = 0;
var waveDelay = 180;
var bulletCooldown = 0;
// Secret wave skip variables (hidden from normal players)
var secretTapCount = 0;
var secretTapTimer = 0;
var secretZone = {
	x: 1900,
	y: 2600,
	width: 148,
	height: 132
}; // Bottom-right corner
// Fast zombie spawn chance (starts at 10%, increases 1% per wave, max 80%)
var fastZombieChance = 10;
// Tough zombie spawn chance (starts at 5% after wave 5, increases 1% per wave, max 90%)
var toughZombieChance = 5;
// Card system variables
var isCardSelectionActive = false;
var cardContainer = null;
var selectedPower = null;
var availablePowers = ['bouncy', 'rapidfire', 'multishot'];
var activePowers = [];
var scoreText = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
var healthText = new Text2('Health: 100', {
	size: 50,
	fill: 0xFF4444
});
healthText.anchor.set(0, 0);
healthText.x = 120;
healthText.y = 20;
LK.gui.topLeft.addChild(healthText);
var waveText = new Text2('Wave: 1', {
	size: 50,
	fill: 0x4A90E2
});
waveText.anchor.set(1, 0);
LK.gui.topRight.addChild(waveText);
// Power utility functions
function getPowerTitle(powerType) {
	switch (powerType) {
		case 'bouncy':
			return 'Bouncy Bullets';
		case 'rapidfire':
			return 'Rapid Fire';
		case 'multishot':
			return 'Multi Shot';
		default:
			return 'Unknown Power';
	}
}
function getPowerDescription(powerType) {
	switch (powerType) {
		case 'bouncy':
			return 'Bullets bounce to nearby enemies';
		case 'rapidfire':
			return 'Faster shooting speed';
		case 'multishot':
			return 'Shoot 3 bullets at once';
		default:
			return 'Unknown effect';
	}
}
function showCardSelection() {
	isCardSelectionActive = true;
	// Create card container
	cardContainer = new Container();
	game.addChild(cardContainer);
	// Create dark overlay
	var overlay = LK.getAsset('background', {
		anchorX: 0,
		anchorY: 0,
		x: 0,
		y: 0,
		alpha: 0.8
	});
	overlay.tint = 0x000000;
	cardContainer.addChild(overlay);
	// Select 3 random powers
	var shuffledPowers = availablePowers.slice();
	for (var i = shuffledPowers.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var temp = shuffledPowers[i];
		shuffledPowers[i] = shuffledPowers[j];
		shuffledPowers[j] = temp;
	}
	var selectedPowers = shuffledPowers.slice(0, 3);
	// Create cards
	for (var i = 0; i < 3; i++) {
		var card = new Card(selectedPowers[i]);
		card.x = 512 + i * 512;
		card.y = 1366;
		cardContainer.addChild(card);
		// Animate cards in
		tween(card, {
			y: 1000
		}, {
			duration: 500,
			easing: tween.easeOut
		});
	}
	// Add title text
	var titleText = new Text2('Choose Your Power!', {
		size: 80,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.x = 1024;
	titleText.y = 600;
	cardContainer.addChild(titleText);
}
function selectCard(powerType) {
	if (!isCardSelectionActive) return;
	// Add power to active powers
	activePowers.push(powerType);
	// Apply power effect
	applyPowerEffect(powerType);
	// Animate cards out and clean up
	if (cardContainer) {
		tween(cardContainer, {
			alpha: 0
		}, {
			duration: 300,
			onFinish: function onFinish() {
				if (cardContainer) {
					cardContainer.destroy();
				}
				cardContainer = null;
				isCardSelectionActive = false;
			}
		});
	}
}
function applyPowerEffect(powerType) {
	switch (powerType) {
		case 'rapidfire':
			player.fireRate = Math.max(2, player.fireRate - 3);
			break;
		case 'multishot':
			// Multishot effect will be handled in bullet creation
			break;
		case 'bouncy':
			// Bouncy effect will be handled in bullet collision
			break;
	}
}
var background = game.addChild(LK.getAsset('background', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0
}));
player = game.addChild(new Player());
player.x = 1024;
player.y = 1366;
function spawnMonster() {
	if (monstersSpawned >= monstersInWave) return;
	// Spawn multiple monsters at once based on wave number - more balanced progression
	var monstersToSpawn = 1;
	if (waveNumber >= 3) monstersToSpawn = 2;
	if (waveNumber >= 6) monstersToSpawn = 3;
	if (waveNumber >= 10) monstersToSpawn = Math.min(4, Math.floor(waveNumber / 3));
	var actualSpawn = Math.min(monstersToSpawn, monstersInWave - monstersSpawned);
	for (var spawnIndex = 0; spawnIndex < actualSpawn; spawnIndex++) {
		// Calculate current tough zombie chance (5% base + 1% per wave after wave 10, max 90%)
		var currentToughZombieChance = waveNumber >= 10 ? Math.min(5 + (waveNumber - 10), 90) : 0;
		// Determine zombie type with priority: tough > fast > normal
		var randomChance = Math.random() * 100;
		var monster;
		if (waveNumber >= 10 && randomChance < currentToughZombieChance) {
			monster = new ToughZombie();
		} else if (waveNumber >= 5 && randomChance < currentToughZombieChance + fastZombieChance) {
			monster = new FastZombie();
		} else {
			monster = new Monster();
		}
		var side = Math.floor(Math.random() * 4);
		switch (side) {
			case 0:
				// Top
				monster.x = Math.random() * 2048;
				monster.y = -30;
				break;
			case 1:
				// Right
				monster.x = 2078;
				monster.y = Math.random() * 2732;
				break;
			case 2:
				// Bottom
				monster.x = Math.random() * 2048;
				monster.y = 2762;
				break;
			case 3:
				// Left
				monster.x = -30;
				monster.y = Math.random() * 2732;
				break;
		}
		// Speed is already set in the class constructors
		monsters.push(monster);
		game.addChild(monster);
		monstersSpawned++;
	}
}
function cleanupBullets() {
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		if (!bullet.active) {
			bullet.destroy();
			bullets.splice(i, 1);
		}
	}
}
function cleanupMonsters() {
	for (var i = monsters.length - 1; i >= 0; i--) {
		var monster = monsters[i];
		if (!monster.active) {
			monster.destroy();
			monsters.splice(i, 1);
			monstersKilled++;
		}
	}
}
function cleanupBloodSplats() {
	for (var i = bloodSplats.length - 1; i >= 0; i--) {
		var bloodSplat = bloodSplats[i];
		if (!bloodSplat.parent) {
			bloodSplats.splice(i, 1);
		}
	}
}
function checkBulletCollisions() {
	for (var i = 0; i < bullets.length; i++) {
		var bullet = bullets[i];
		if (!bullet.active) continue;
		for (var j = 0; j < monsters.length; j++) {
			var monster = monsters[j];
			if (!monster.active) continue;
			if (bullet.intersects(monster)) {
				monster.takeDamage(1);
				// If this bullet already bounced and hit its target, deactivate it
				if (bullet.bounced && bullet.bounceTarget === monster) {
					bullet.active = false;
					break;
				}
				// Try to bounce bullet if bouncy power is active and bullet hasn't bounced yet
				if (!bullet.bounced && activePowers.indexOf('bouncy') !== -1) {
					bullet.bounce(monster);
					// If bounce was successful (found a target), keep bullet active
					if (bullet.bounced) {
						break; // Stop checking other monsters for this bullet this frame
					}
				}
				// Only deactivate bullet if it didn't bounce or bouncy power is not active
				if (!bullet.bounced || activePowers.indexOf('bouncy') === -1) {
					bullet.active = false;
				}
				break;
			}
		}
	}
}
function nextWave() {
	waveNumber++;
	// Check for card selection every 5 waves
	if (waveNumber % 5 === 0 && waveNumber > 0) {
		showCardSelection();
		return; // Don't start next wave until card is selected
	}
	// More balanced wave size progression: slower growth after wave 10
	if (waveNumber <= 10) {
		monstersInWave = 3 + waveNumber * 2;
	} else {
		monstersInWave = 23 + Math.floor((waveNumber - 10) / 2);
	}
	monstersSpawned = 0;
	monstersKilled = 0;
	spawnTimer = 0;
	waveDelay = 180;
	// Increase fast zombie chance by 1% each wave, max 80%
	fastZombieChance = Math.min(10 + waveNumber, 80);
	waveText.setText('Wave: ' + waveNumber);
}
game.down = function (x, y, obj) {
	// Secret wave skip check (bottom-right corner taps)
	if (x >= secretZone.x && x <= secretZone.x + secretZone.width && y >= secretZone.y && y <= secretZone.y + secretZone.height) {
		secretTapCount++;
		secretTapTimer = 120; // 2 seconds to complete sequence
		if (secretTapCount >= 5) {
			// Skip 3 waves
			var skipAmount = 3;
			// Skip waves instantly
			for (var skipCount = 0; skipCount < skipAmount; skipCount++) {
				waveNumber++;
			}
			// Calculate wave size using balanced progression
			if (waveNumber <= 10) {
				monstersInWave = 3 + waveNumber * 2;
			} else {
				monstersInWave = 23 + Math.floor((waveNumber - 10) / 2);
			}
			// Update fast zombie chance for the new wave
			fastZombieChance = Math.min(10 + waveNumber, 80);
			monstersSpawned = 0;
			monstersKilled = monstersInWave;
			// Clear all current monsters
			for (var i = 0; i < monsters.length; i++) {
				if (monsters[i].active) {
					monsters[i].active = false;
				}
			}
			secretTapCount = 0;
			waveText.setText('Wave: ' + waveNumber);
			// Visual feedback (brief flash)
			LK.effects.flashScreen(0x00ff00, 200);
		}
		return;
	}
	if (bulletCooldown <= 0 && player.fire()) {
		// Check if multishot is active
		var shotCount = activePowers.indexOf('multishot') !== -1 ? 3 : 1;
		for (var shotIndex = 0; shotIndex < shotCount; shotIndex++) {
			var bullet = new Bullet();
			bullet.x = player.x;
			bullet.y = player.y;
			if (shotCount === 1) {
				// Single shot - aim directly at target
				bullet.setDirection(x, y);
			} else {
				// Multishot - spread bullets
				var baseAngle = Math.atan2(y - player.y, x - player.x);
				var spreadAngle = (shotIndex - 1) * 0.3; // 0.3 radians spread
				var finalAngle = baseAngle + spreadAngle;
				var targetX = player.x + Math.cos(finalAngle) * 500;
				var targetY = player.y + Math.sin(finalAngle) * 500;
				bullet.setDirection(targetX, targetY);
			}
			bullets.push(bullet);
			game.addChild(bullet);
		}
		LK.getSound('shoot').play();
		bulletCooldown = 30;
	}
};
LK.playMusic('bgmusic');
game.update = function () {
	// Pause game during card selection
	if (isCardSelectionActive) {
		return;
	}
	// Secret wave skip timer
	if (secretTapTimer > 0) {
		secretTapTimer--;
		if (secretTapTimer <= 0) {
			secretTapCount = 0; // Reset if too slow
		}
	}
	if (bulletCooldown > 0) {
		bulletCooldown--;
	}
	if (waveDelay > 0) {
		waveDelay--;
		return;
	}
	spawnTimer++;
	if (spawnTimer >= 60 && monstersSpawned < monstersInWave) {
		spawnMonster();
		spawnTimer = 0;
	}
	checkBulletCollisions();
	cleanupBullets();
	cleanupMonsters();
	cleanupBloodSplats();
	if (monstersKilled >= monstersInWave && monsters.length === 0) {
		nextWave();
	}
	scoreText.setText('Score: ' + LK.getScore());
	healthText.setText('Health: ' + player.health);
};

===================================================================
--- original.js
+++ change.js
@@ -63,11 +63,11 @@
 		}
 	};
 	self.bounce = function (hitMonster) {
 		if (self.bounced || activePowers.indexOf('bouncy') === -1) return;
-		// Find nearest monster within bounce range
+		// Find nearest monster regardless of distance
 		var nearestMonster = null;
-		var nearestDistance = 300; // Bounce range
+		var nearestDistance = Infinity; // No distance limit
 		for (var i = 0; i < monsters.length; i++) {
 			var monster = monsters[i];
 			if (!monster.active || monster === hitMonster) continue;
 			var dx = monster.x - self.x;
@@ -79,10 +79,14 @@
 			}
 		}
 		if (nearestMonster) {
 			self.bounced = true;
+			self.bounceTarget = nearestMonster; // Store the target
 			self.setDirection(nearestMonster.x, nearestMonster.y);
 			graphics.tint = 0x00FF00; // Green tint for bounced bullets
+		} else {
+			// No target found, deactivate bullet
+			self.active = false;
 		}
 	};
 	return self;
 });
@@ -634,8 +638,13 @@
 			var monster = monsters[j];
 			if (!monster.active) continue;
 			if (bullet.intersects(monster)) {
 				monster.takeDamage(1);
+				// If this bullet already bounced and hit its target, deactivate it
+				if (bullet.bounced && bullet.bounceTarget === monster) {
+					bullet.active = false;
+					break;
+				}
 				// Try to bounce bullet if bouncy power is active and bullet hasn't bounced yet
 				if (!bullet.bounced && activePowers.indexOf('bouncy') !== -1) {
 					bullet.bounce(monster);
 					// If bounce was successful (found a target), keep bullet active