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

/**** 
* Classes
****/ 
var AuraAbility = Container.expand(function () {
	var self = Container.call(this);
	self.radius = 300;
	self.damage = 15;
	self.tickCounter = 0;
	self.ticksPerDamage = 60;
	self.damageThisFrame = {};
	self.update = function () {
		self.tickCounter++;
		if (self.tickCounter >= self.ticksPerDamage) {
			self.tickCounter = 0;
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				var dx = enemy.x - player.x;
				var dy = enemy.y - player.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < self.radius) {
					if (!self.damageThisFrame[i]) {
						enemy.health -= self.damage;
						enemy.healthBar.updateHealth(enemy.health);
						self.damageThisFrame[i] = true;
						if (enemy.health <= 0) {
							playerExp += 25;
							if (playerExp >= expToNextLevel) {
								playerExp -= expToNextLevel;
								playerLevel += 1;
								expToNextLevel = Math.floor(expToNextLevel * 1.2);
								playerHealth += 20;
								showLevelUpPanel();
							}
							enemy.destroy();
							enemies.splice(enemies.indexOf(enemy), 1);
						}
					}
				} else {
					self.damageThisFrame[i] = false;
				}
			}
		}
	};
	return self;
});
var DualShot = Container.expand(function () {
	var self = Container.call(this);
	self.fireProjectiles = function (fromX, fromY, targetEnemies) {
		var closestZombie = null;
		var closestZombieDistance = Infinity;
		var closestSkeleton = null;
		var closestSkeletonDistance = Infinity;
		for (var i = 0; i < targetEnemies.length; i++) {
			var enemy = targetEnemies[i];
			var dx = enemy.x - fromX;
			var dy = enemy.y - fromY;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (enemy.constructor.name === 'Skeleton') {
				if (distance < closestSkeletonDistance) {
					closestSkeletonDistance = distance;
					closestSkeleton = enemy;
				}
			} else {
				if (distance < closestZombieDistance) {
					closestZombieDistance = distance;
					closestZombie = enemy;
				}
			}
		}
		var firstTarget = closestZombie;
		var secondTarget = closestSkeleton;
		if (!firstTarget && !secondTarget) return;
		if (!firstTarget && secondTarget) firstTarget = secondTarget;
		if (!secondTarget && firstTarget) secondTarget = firstTarget;
		if (firstTarget) {
			var projectile1 = new Projectile();
			projectile1.x = fromX;
			projectile1.y = fromY;
			projectile1.damage = playerStats.damage;
			projectile1.targetEnemy = firstTarget;
			projectiles.push(projectile1);
			game.addChild(projectile1);
		}
		if (secondTarget && secondTarget !== firstTarget) {
			var projectile2 = new Projectile();
			projectile2.x = fromX;
			projectile2.y = fromY;
			projectile2.damage = playerStats.damage;
			projectile2.targetEnemy = secondTarget;
			projectiles.push(projectile2);
			game.addChild(projectile2);
		}
	};
	return self;
});
var EnemyHealthBar = Container.expand(function () {
	var self = Container.call(this);
	self.maxHealth = 50;
	self.currentHealth = 50;
	var barBackground = LK.getAsset('healthBarBg', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(barBackground);
	var barFill = LK.getAsset('healthBarFill', {
		anchorX: 0.0,
		anchorY: 0.5
	});
	self.addChild(barFill);
	self.barFill = barFill;
	self.updateHealth = function (currentHealth) {
		self.currentHealth = currentHealth;
		var healthPercent = Math.max(0, currentHealth / self.maxHealth);
		self.barFill.scaleX = healthPercent;
	};
	return self;
});
var EnemyProjectile = Container.expand(function () {
	var self = Container.call(this);
	var projectileGraphics = self.attachAsset('projectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	projectileGraphics.tint = 0xff0000;
	self.speed = 8;
	self.damage = 15;
	self.health = 20;
	self.maxHealth = 20;
	self.lastWasIntersecting = false;
	self.directionX = 0;
	self.directionY = 0;
	self.isFixedTrajectory = false;
	self.update = function () {
		if (self.isFixedTrajectory) {
			self.x += self.directionX * self.speed;
			self.y += self.directionY * self.speed;
		} else if (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;
			}
		}
		var currentIntersecting = self.intersects(player);
		if (!self.lastWasIntersecting && currentIntersecting) {
			playerHealth -= self.damage;
			self.destroy();
			enemyProjectiles.splice(enemyProjectiles.indexOf(self), 1);
		}
		self.lastWasIntersecting = currentIntersecting;
		if (self.x < -100 || self.x > 2148 || self.y < -100 || self.y > 2832) {
			self.destroy();
			enemyProjectiles.splice(enemyProjectiles.indexOf(self), 1);
		}
	};
	return self;
});
var HealthPickup = Container.expand(function () {
	var self = Container.call(this);
	//{4M_health}
	var pickupGraphics = self.attachAsset('healthPickup', {
		anchorX: 0.5,
		anchorY: 0.5
	}); //{4M_health2}
	self.healAmount = 30;
	self.lastWasIntersecting = false;
	self.update = function () {
		var currentIntersecting = self.intersects(player);
		if (!self.lastWasIntersecting && currentIntersecting) {
			playerHealth = Math.min(playerHealth + self.healAmount, playerStats.maxHealth);
			healthText.setText('Health: ' + playerHealth);
			self.destroy();
			healthPickups.splice(healthPickups.indexOf(self), 1);
		}
		self.lastWasIntersecting = currentIntersecting;
	};
	return self;
});
var LevelUpPanel = Container.expand(function () {
	var self = Container.call(this);
	self.panelBg = self.attachAsset('levelUpBg', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = 1024;
	self.y = 1366;
	var titleText = new Text2('LEVEL UP!', {
		size: 80,
		fill: 0xFFFF00
	});
	titleText.anchor.set(0.5, 0);
	titleText.y = -180;
	self.addChild(titleText);
	var buttonWidth = 300;
	var buttonHeight = 80;
	var buttonSpacingX = 350;
	var buttonSpacingY = 140;
	var startX = -175;
	var startY = -70;
	var statUpgrades = [{
		label: 'Health +20',
		key: 'maxHealth',
		value: 20,
		stat: 'playerStats.maxHealth'
	}, {
		label: 'Attack Speed +0.2',
		key: 'attackSpeed',
		value: 0.2,
		stat: 'playerStats.attackSpeed'
	}, {
		label: 'Damage +10',
		key: 'damage',
		value: 10,
		stat: 'playerStats.damage'
	}, {
		label: 'Speed +2',
		key: 'speed',
		value: 2,
		stat: 'playerStats.speed'
	}];
	var abilityUpgrades = [{
		label: 'Aura Ability',
		key: 'auraAbility',
		value: 1,
		stat: 'auraAbility'
	}, {
		label: 'Spikes Armor',
		key: 'spikesArmor',
		value: 1,
		stat: 'spikesArmor'
	}, {
		label: 'Dual Shot',
		key: 'dualShot',
		value: 1,
		stat: 'dualShot'
	}];
	var upgrades = [];
	for (var i = 0; i < 3; i++) {
		upgrades.push(statUpgrades[i]);
	}
	var randomAbilityIndex = Math.floor(Math.random() * abilityUpgrades.length);
	upgrades.push(abilityUpgrades[randomAbilityIndex]);
	var buttons = [];
	for (var i = 0; i < upgrades.length; i++) {
		var btn = self.attachAsset('upgradeButton', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		btn.x = startX + i % 2 * buttonSpacingX;
		btn.y = startY + Math.floor(i / 2) * buttonSpacingY;
		btn.upgradeKey = upgrades[i].key;
		btn.upgradeValue = upgrades[i].value;
		var btnText = new Text2(upgrades[i].label, {
			size: 40,
			fill: 0xFFFFFF
		});
		btnText.anchor.set(0.5, 0.5);
		btn.addChild(btnText);
		buttons.push(btn);
		self.addChild(btn);
	}
	self.buttons = buttons;
	self.autoSelectTimer = null;
	self.startAutoSelect = function () {
		self.autoSelectTimer = LK.setTimeout(function () {
			var randomIndex = Math.floor(Math.random() * self.buttons.length);
			var btn = self.buttons[randomIndex];
			var key = btn.upgradeKey;
			var value = btn.upgradeValue;
			if (key === 'maxHealth') {
				playerStats.maxHealth += value;
				playerHealth = playerStats.maxHealth;
			} else if (key === 'attackSpeed') {
				playerStats.attackSpeed += value;
			} else if (key === 'damage') {
				playerStats.damage += value;
			} else if (key === 'speed') {
				playerStats.speed += value;
				playerSpeed = playerStats.speed;
			} else if (key === 'auraAbility') {
				if (!playerAuraAbility) {
					playerAuraAbility = new AuraAbility();
					game.addChild(playerAuraAbility);
					playerAuraAbility.x = player.x;
					playerAuraAbility.y = player.y;
				}
			} else if (key === 'spikesArmor') {
				if (!playerSpikesArmor) {
					playerSpikesArmor = new SpikesArmor();
					playerSpikesArmor.active = true;
				}
			} else if (key === 'dualShot') {
				if (!playerDualShot) {
					playerDualShot = new DualShot();
				}
			}
			closeLevelUpPanel();
		}, 5000);
	};
	self.cancelAutoSelect = function () {
		if (self.autoSelectTimer !== null) {
			LK.clearTimeout(self.autoSelectTimer);
			self.autoSelectTimer = null;
		}
	};
	self.down = function (x, y, obj) {
		for (var i = 0; i < self.buttons.length; i++) {
			var btn = self.buttons[i];
			var btnGlobalPos = btn.parent.toGlobal(btn.position);
			var localPos = {
				x: x - btnGlobalPos.x,
				y: y - btnGlobalPos.y
			};
			if (localPos.x >= -btn.width / 2 && localPos.x <= btn.width / 2 && localPos.y >= -btn.height / 2 && localPos.y <= btn.height / 2) {
				self.cancelAutoSelect();
				var key = btn.upgradeKey;
				var value = btn.upgradeValue;
				if (key === 'maxHealth') {
					playerStats.maxHealth += value;
					playerHealth = playerStats.maxHealth;
				} else if (key === 'attackSpeed') {
					playerStats.attackSpeed += value;
				} else if (key === 'damage') {
					playerStats.damage += value;
				} else if (key === 'speed') {
					playerStats.speed += value;
					playerSpeed = playerStats.speed;
				} else if (key === 'auraAbility') {
					if (!playerAuraAbility) {
						playerAuraAbility = new AuraAbility();
						game.addChild(playerAuraAbility);
						playerAuraAbility.x = player.x;
						playerAuraAbility.y = player.y;
					}
				} else if (key === 'spikesArmor') {
					if (!playerSpikesArmor) {
						playerSpikesArmor = new SpikesArmor();
						playerSpikesArmor.active = true;
					}
				} else if (key === 'dualShot') {
					if (!playerDualShot) {
						playerDualShot = new DualShot();
					}
				}
				closeLevelUpPanel();
				break;
			}
		}
	};
	return self;
});
var Projectile = Container.expand(function () {
	var self = Container.call(this);
	var projectileGraphics = self.attachAsset('projectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 12;
	self.damage = playerStats.damage;
	self.health = 50;
	self.maxHealth = 50;
	self.lastWasIntersecting = {};
	self.update = function () {
		if (self.targetEnemy && !self.targetEnemy.destroyed) {
			var dx = self.targetEnemy.x - self.x;
			var dy = self.targetEnemy.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;
			}
			var currentIntersecting = self.intersects(self.targetEnemy);
			if (!self.lastWasIntersecting[self.targetEnemy] && currentIntersecting) {
				self.targetEnemy.health -= self.damage;
				self.targetEnemy.healthBar.updateHealth(self.targetEnemy.health);
				if (self.targetEnemy.health <= 0) {
					playerExp += 25;
					if (playerExp >= expToNextLevel) {
						playerExp -= expToNextLevel;
						playerLevel += 1;
						expToNextLevel = Math.floor(expToNextLevel * 1.2);
						playerHealth += 20;
						showLevelUpPanel();
					}
					self.targetEnemy.destroy();
					enemies.splice(enemies.indexOf(self.targetEnemy), 1);
				}
				self.destroy();
				projectiles.splice(projectiles.indexOf(self), 1);
			}
			self.lastWasIntersecting[self.targetEnemy] = currentIntersecting;
			for (var i = enemyProjectiles.length - 1; i >= 0; i--) {
				if (self.intersects(enemyProjectiles[i])) {
					self.health -= 25;
					enemyProjectiles[i].destroy();
					enemyProjectiles.splice(i, 1);
					if (self.health <= 0) {
						self.destroy();
						projectiles.splice(projectiles.indexOf(self), 1);
						return;
					}
				}
			}
		} else if (self.x < -100 || self.x > 2148 || self.y < -100 || self.y > 2832) {
			self.destroy();
			projectiles.splice(projectiles.indexOf(self), 1);
		}
	};
	return self;
});
var Skeleton = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemySquare', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	enemyGraphics.tint = 0xff00ff;
	var healthBar = new EnemyHealthBar();
	healthBar.y = -60;
	self.addChild(healthBar);
	self.healthBar = healthBar;
	self.speed = 1.5;
	self.health = 70;
	self.maxHealth = 70;
	self.attackRange = 800;
	self.attackCooldown = 0;
	self.attackCooldownMax = 120;
	self.lastWasIntersecting = false;
	self.update = function () {
		if (player) {
			var dx = player.x - self.x;
			var dy = player.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > self.attackRange + 100) {
				if (distance > 0) {
					self.x += dx / distance * self.speed;
					self.y += dy / distance * self.speed;
				}
			} else {
				self.attackCooldown++;
				if (self.attackCooldown >= self.attackCooldownMax) {
					self.attackCooldown = 0;
					var projectile = new EnemyProjectile();
					projectile.x = self.x;
					projectile.y = self.y;
					projectile.isFixedTrajectory = true;
					var angle = Math.random() * Math.PI * 2;
					projectile.directionX = Math.cos(angle);
					projectile.directionY = Math.sin(angle);
					enemyProjectiles.push(projectile);
					game.addChild(projectile);
				}
			}
		}
		var currentIntersecting = self.intersects(player);
		if (!self.lastWasIntersecting && currentIntersecting) {
			var damageDealt = 10;
			playerHealth -= damageDealt;
			if (playerSpikesArmor && playerSpikesArmor.active) {
				var reflectedDamage = Math.ceil(damageDealt * playerSpikesArmor.reflectPercentage);
				self.health -= reflectedDamage;
				self.healthBar.updateHealth(self.health);
				if (self.health <= 0) {
					playerExp += 50;
					if (playerExp >= expToNextLevel) {
						playerExp -= expToNextLevel;
						playerLevel += 1;
						expToNextLevel = Math.floor(expToNextLevel * 1.2);
						playerHealth += 20;
						showLevelUpPanel();
					}
					self.destroy();
					enemies.splice(enemies.indexOf(self), 1);
				}
			}
			if (playerHealth <= 0) {
				LK.showGameOver();
			}
		}
		self.lastWasIntersecting = currentIntersecting;
	};
	return self;
});
//{4M_health3}
var SpikesArmor = Container.expand(function () {
	var self = Container.call(this);
	self.reflectPercentage = 0.3;
	self.active = true;
	return self;
});
var Zombie = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemySquare', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var healthBar = new EnemyHealthBar();
	healthBar.y = -60;
	self.addChild(healthBar);
	self.healthBar = healthBar;
	self.speed = 2;
	self.health = 50;
	self.lastWasIntersecting = false;
	self.update = function () {
		if (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;
			}
		}
		var currentIntersecting = self.intersects(player);
		if (!self.lastWasIntersecting && currentIntersecting) {
			var damageDealt = 10;
			playerHealth -= damageDealt;
			if (playerSpikesArmor && playerSpikesArmor.active) {
				var reflectedDamage = Math.ceil(damageDealt * playerSpikesArmor.reflectPercentage);
				self.health -= reflectedDamage;
				self.healthBar.updateHealth(self.health);
				if (self.health <= 0) {
					playerExp += 25;
					if (playerExp >= expToNextLevel) {
						playerExp -= expToNextLevel;
						playerLevel += 1;
						expToNextLevel = Math.floor(expToNextLevel * 1.2);
						playerHealth += 20;
						showLevelUpPanel();
					}
					self.destroy();
					enemies.splice(enemies.indexOf(self), 1);
				}
			}
			if (playerHealth <= 0) {
				LK.showGameOver();
			}
		}
		self.lastWasIntersecting = currentIntersecting;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var player = game.addChild(new Container());
var playerGraphics = player.attachAsset('personaje', {
	anchorX: 0.5,
	anchorY: 0.5
});
player.x = 1024;
player.y = 1366;
var playerHealth = 100;
var playerExp = 0;
var playerLevel = 1;
var expToNextLevel = 100;
var enemies = [];
var projectiles = [];
var enemyProjectiles = [];
var healthPickups = [];
var keysPressed = {};
var playerSpeed = 8;
var healthText = new Text2('Health: ' + playerHealth, {
	size: 60,
	fill: 0xFFFFFF
});
healthText.anchor.set(0.5, 0);
LK.gui.top.addChild(healthText);
var expText = new Text2('Level: ' + playerLevel + ' | EXP: ' + playerExp + '/' + expToNextLevel, {
	size: 50,
	fill: 0x00FF00
});
expText.anchor.set(0.5, 0);
expText.y = 70;
LK.gui.top.addChild(expText);
var levelUpPanel = null;
var playerStats = {
	maxHealth: 100,
	attackSpeed: 1.0,
	damage: 25,
	speed: 8
};
var playerAuraAbility = null;
var playerSpikesArmor = null;
var playerDualShot = null;
function showLevelUpPanel() {
	if (!levelUpPanel) {
		levelUpPanel = new LevelUpPanel();
		game.addChild(levelUpPanel);
		game.paused = true;
		levelUpPanel.startAutoSelect();
	}
}
function closeLevelUpPanel() {
	if (levelUpPanel) {
		levelUpPanel.cancelAutoSelect();
		levelUpPanel.destroy();
		levelUpPanel = null;
		game.paused = false;
	}
}
game.move = function (x, y, obj) {
	var touchX = x;
	var touchY = y;
	var dx = touchX - player.x;
	var dy = touchY - player.y;
	var distance = Math.sqrt(dx * dx + dy * dy);
	if (distance > 50) {
		player.x += dx / distance * playerSpeed;
		player.y += dy / distance * playerSpeed;
		if (player.x < 0) player.x = 0;
		if (player.x > 2048) player.x = 2048;
		if (player.y < 0) player.y = 0;
		if (player.y > 2732) player.y = 2732;
	}
};
game.down = function (x, y, obj) {
	if (levelUpPanel) {
		levelUpPanel.down(x, y, obj);
	}
};
game.update = function () {
	if (LK.ticks % 60 === 0) {
		var angle = Math.random() * Math.PI * 2;
		var distance = 600;
		var spawnX = player.x + Math.cos(angle) * distance;
		var spawnY = player.y + Math.sin(angle) * distance;
		var spawnType = Math.random() < 0.7 ? 'zombie' : 'skeleton';
		var newEnemy = spawnType === 'skeleton' ? new Skeleton() : new Zombie();
		newEnemy.x = spawnX;
		newEnemy.y = spawnY;
		enemies.push(newEnemy);
		game.addChild(newEnemy);
	}
	if (LK.ticks % 1500 === 0) {
		var angle = Math.random() * Math.PI * 2;
		var distance = 400;
		var pickupX = player.x + Math.cos(angle) * distance;
		var pickupY = player.y + Math.sin(angle) * distance;
		var healthPickup = new HealthPickup();
		healthPickup.x = pickupX;
		healthPickup.y = pickupY;
		healthPickups.push(healthPickup);
		game.addChild(healthPickup);
	}
	if (LK.ticks % 30 === 0 && enemies.length > 0) {
		if (playerDualShot) {
			playerDualShot.fireProjectiles(player.x, player.y, enemies);
		} else {
			var closestEnemy = null;
			var closestDistance = Infinity;
			for (var i = 0; i < enemies.length; i++) {
				var dx = enemies[i].x - player.x;
				var dy = enemies[i].y - player.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < closestDistance && enemies[i].constructor.name !== 'Skeleton') {
					closestDistance = distance;
					closestEnemy = enemies[i];
				}
			}
			if (closestEnemy) {
				var projectile = new Projectile();
				projectile.x = player.x;
				projectile.y = player.y;
				projectile.damage = playerStats.damage;
				projectile.targetEnemy = closestEnemy;
				projectiles.push(projectile);
				game.addChild(projectile);
			}
		}
	}
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		var dx = player.x - enemy.x;
		var dy = player.y - enemy.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 2000) {
			enemy.destroy();
			enemies.splice(i, 1);
		}
	}
	for (var i = enemyProjectiles.length - 1; i >= 0; i--) {
		enemyProjectiles[i].update();
	}
	if (playerAuraAbility) {
		playerAuraAbility.x = player.x;
		playerAuraAbility.y = player.y;
		playerAuraAbility.update();
	}
	for (var i = healthPickups.length - 1; i >= 0; i--) {
		healthPickups[i].update();
	}
	healthText.setText('Health: ' + playerHealth);
	expText.setText('Level: ' + playerLevel + ' | EXP: ' + playerExp + '/' + expToNextLevel);
};

===================================================================
--- original.js
+++ change.js
@@ -131,28 +131,35 @@
 	self.damage = 15;
 	self.health = 20;
 	self.maxHealth = 20;
 	self.lastWasIntersecting = false;
+	self.directionX = 0;
+	self.directionY = 0;
+	self.isFixedTrajectory = false;
 	self.update = function () {
-		if (player) {
+		if (self.isFixedTrajectory) {
+			self.x += self.directionX * self.speed;
+			self.y += self.directionY * self.speed;
+		} else if (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;
 			}
-			var currentIntersecting = self.intersects(player);
-			if (!self.lastWasIntersecting && currentIntersecting) {
-				playerHealth -= self.damage;
-				self.destroy();
-				enemyProjectiles.splice(enemyProjectiles.indexOf(self), 1);
-			}
-			self.lastWasIntersecting = currentIntersecting;
-		} else if (self.x < -100 || self.x > 2148 || self.y < -100 || self.y > 2832) {
+		}
+		var currentIntersecting = self.intersects(player);
+		if (!self.lastWasIntersecting && currentIntersecting) {
+			playerHealth -= self.damage;
 			self.destroy();
 			enemyProjectiles.splice(enemyProjectiles.indexOf(self), 1);
 		}
+		self.lastWasIntersecting = currentIntersecting;
+		if (self.x < -100 || self.x > 2148 || self.y < -100 || self.y > 2832) {
+			self.destroy();
+			enemyProjectiles.splice(enemyProjectiles.indexOf(self), 1);
+		}
 	};
 	return self;
 });
 var HealthPickup = Container.expand(function () {
@@ -442,8 +449,12 @@
 					self.attackCooldown = 0;
 					var projectile = new EnemyProjectile();
 					projectile.x = self.x;
 					projectile.y = self.y;
+					projectile.isFixedTrajectory = true;
+					var angle = Math.random() * Math.PI * 2;
+					projectile.directionX = Math.cos(angle);
+					projectile.directionY = Math.sin(angle);
 					enemyProjectiles.push(projectile);
 					game.addChild(projectile);
 				}
 			}