/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	topScore: 0
});

/**** 
* Classes
****/ 
//{exp_pickup_23}
var ArmorPickup = Container.expand(function () {
	var self = Container.call(this);
	//{armor_1}
	var pickupGraphics = self.attachAsset('armorPickup', {
		anchorX: 0.5,
		//{armor_2}
		anchorY: 0.5 //{armor_3}
	}); //{armor_4}
	pickupGraphics.tint = 0xcccccc;
	self.armorAmount = 25;
	self.lastWasIntersecting = false; //{armor_5}
	self.update = function () {
		//{armor_6}
		var currentIntersecting = self.intersects(player); //{armor_7}
		if (!self.lastWasIntersecting && currentIntersecting) {
			//{armor_8}
			playerArmor = Math.min(playerArmor + self.armorAmount, playerStats.maxArmor);
			armorText.setText('Armor: ' + playerArmor); //{armor_9}
			self.destroy(); //{armor_10}
			armorPickups.splice(armorPickups.indexOf(self), 1);
		} //{armor_11}
		self.lastWasIntersecting = currentIntersecting; //{armor_12}
	}; //{armor_13}
	return self; //{armor_14}
});
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;
			var enemyCount = enemies.length;
			if (enemyCount === 0) return;
			for (var i = 0; i < enemyCount; i++) {
				var enemy = enemies[i];
				if (!enemy) continue;
				var distance = calculateDistance(player.x, player.y, enemy.x, enemy.y);
				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 Chest = Container.expand(function () {
	var self = Container.call(this);
	var chestGraphics = self.attachAsset('upgradeButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	chestGraphics.tint = 0xFFD700;
	self.opened = false;
	self.lastWasIntersecting = false;
	self.update = function () {
		var currentIntersecting = self.intersects(player);
		if (!self.lastWasIntersecting && currentIntersecting && !self.opened) {
			self.opened = true;
			var abilityUpgrades = [{
				label: 'Aura Ability',
				key: 'auraAbility'
			}, {
				label: 'Spikes Armor',
				key: 'spikesArmor'
			}, {
				label: 'Dual Shot',
				key: 'dualShot'
			}, {
				label: 'Push Hand',
				key: 'pushHand'
			}];
			var randomAbility = abilityUpgrades[Math.floor(Math.random() * abilityUpgrades.length)];
			var key = randomAbility.key;
			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();
				}
			} else if (key === 'pushHand') {
				if (!playerPushHand) {
					playerPushHand = new PushHand();
					game.addChild(playerPushHand);
					playerPushHand.x = player.x;
					playerPushHand.y = player.y;
				}
			}
			LK.effects.flashObject(self, 0xFFFF00, 500);
		}
		self.lastWasIntersecting = currentIntersecting;
	};
	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('enemyProjectileSpiky', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	projectileGraphics.tint = 0xff2222;
	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.fromSkeleton = false;
	self.update = function () {
		if (self.isFixedTrajectory) {
			self.x += self.directionX * self.speed;
			self.y += self.directionY * self.speed;
		} else if (player) {
			var distance = calculateDistance(self.x, self.y, player.x, player.y);
			if (distance > 0) {
				var dx = player.x - self.x;
				var dy = player.y - self.y;
				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;
});
//{wave_49}
var ExpPickup = Container.expand(function () {
	var self = Container.call(this);
	//{exp_pickup_1}
	var pickupGraphics = self.attachAsset('expPickupVisual', {
		anchorX: 0.5,
		//{exp_pickup_2}
		anchorY: 0.5 //{exp_pickup_3}
	}); //{exp_pickup_4}
	pickupGraphics.tint = 0xFFD700;
	pickupGraphics.scaleX = 1.0;
	pickupGraphics.scaleY = 1.0;
	self.expAmount = 25;
	self.lastWasIntersecting = false; //{exp_pickup_5}
	self.velocityX = 0;
	self.velocityY = 0;
	self.gravity = 0.3;
	self.friction = 0.98;
	self.isMoving = true;
	self.settleTime = 60;
	self.settleCounter = 0;
	self.update = function () {
		//{exp_pickup_6}
		if (self.isMoving) {
			self.velocityY += self.gravity;
			self.velocityX *= self.friction;
			self.velocityY *= self.friction;
			self.x += self.velocityX;
			self.y += self.velocityY;
			self.settleCounter++;
			if (self.settleCounter >= self.settleTime || Math.abs(self.velocityX) < 0.1 && Math.abs(self.velocityY) < 0.1) {
				self.isMoving = false;
				self.velocityX = 0;
				self.velocityY = 0;
				pickupGraphics.alpha = 1.0;
			}
		}
		var pickupRadius = 40;
		var distanceToPlayer = calculateDistance(self.x, self.y, player.x, player.y);
		var currentIntersecting = distanceToPlayer < pickupRadius; //{exp_pickup_7}
		if (!self.lastWasIntersecting && currentIntersecting) {
			//{exp_pickup_8}
			playerExp += self.expAmount; //{exp_pickup_9}
			if (playerExp >= expToNextLevel) {
				//{exp_pickup_10}
				playerExp -= expToNextLevel; //{exp_pickup_11}
				playerLevel += 1; //{exp_pickup_12}
				expToNextLevel = Math.floor(expToNextLevel * 1.2); //{exp_pickup_13}
				playerHealth += 20; //{exp_pickup_14}
				showLevelUpPanel(); //{exp_pickup_15}
			} //{exp_pickup_16}
			self.destroy(); //{exp_pickup_17}
			expPickups.splice(expPickups.indexOf(self), 1); //{exp_pickup_18}
		} //{exp_pickup_19}
		self.lastWasIntersecting = currentIntersecting; //{exp_pickup_20}
	}; //{exp_pickup_21}
	return self; //{exp_pickup_22}
});
//{armor_15}
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 IceProjectile = Container.expand(function () {
	var self = Container.call(this);
	var projectileGraphics = self.attachAsset('iceProjectileSpiky', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	projectileGraphics.tint = 0x00ddff;
	self.speed = 12;
	self.damage = playerStats.damage;
	self.freezeDuration = 300;
	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.frozen) {
					self.targetEnemy.frozen = true;
					self.targetEnemy.freezeEndTime = LK.ticks + self.freezeDuration;
					tween(self.targetEnemy.scale, {
						x: 1,
						y: 1
					}, {
						duration: 100
					});
					self.targetEnemy.tint = 0x0099FF;
				}
				if (self.targetEnemy.health <= 0) {
					playerScore += 100;
					scoreText.setText('Score: ' + playerScore);
					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 (!enemyProjectiles[i].fromSkeleton && 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 IceShot = Container.expand(function () {
	var self = Container.call(this);
	self.fireProjectiles = function (fromX, fromY, targetEnemies) {
		if (targetEnemies.length === 0) return;
		var closestEnemy = null;
		var closestDistance = 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 (distance < closestDistance) {
				closestDistance = distance;
				closestEnemy = enemy;
			}
		}
		if (closestEnemy) {
			var projectile = new IceProjectile();
			projectile.x = fromX;
			projectile.y = fromY;
			projectile.damage = playerStats.damage;
			projectile.targetEnemy = closestEnemy;
			projectiles.push(projectile);
			game.addChild(projectile);
		}
	};
	return self;
});
var InventoryPanel = Container.expand(function () {
	var self = Container.call(this);
	self.slots = [];
	var slotWidth = 150;
	var slotHeight = 150;
	var slotSpacing = 170;
	var panelStartX = 100;
	var panelStartY = 100;
	for (var i = 0; i < 10; i++) {
		var slot = self.attachAsset('upgradeButton', {
			anchorX: 0,
			anchorY: 0
		});
		slot.scaleX = 0.5;
		slot.scaleY = 0.5;
		slot.x = panelStartX + i % 5 * slotSpacing;
		slot.y = panelStartY + Math.floor(i / 5) * slotSpacing;
		slot.hasChest = false;
		var slotText = new Text2('Empty', {
			size: 20,
			fill: 0xFFFFFF
		});
		slotText.anchor.set(0.5, 0.5);
		slotText.x = slot.width / 4;
		slotText.y = slot.height / 4;
		slot.addChild(slotText);
		self.slots.push(slot);
		self.addChild(slot);
	}
	self.spawnChests = function () {
		for (var i = 0; i < self.slots.length; i++) {
			if (Math.random() < 0.3 && !self.slots[i].hasChest) {
				self.slots[i].hasChest = true;
				var chest = new Chest();
				chest.x = self.slots[i].x + self.slots[i].width / 4;
				chest.y = self.slots[i].y + self.slots[i].height / 4;
				chests.push(chest);
				game.addChild(chest);
			}
		}
	};
	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: 100,
		fill: 0xFFD700
	});
	titleText.anchor.set(0.5, 0);
	titleText.y = -220;
	self.addChild(titleText);
	var levelText = new Text2('Level ' + playerLevel, {
		size: 60,
		fill: 0x00FF00
	});
	levelText.anchor.set(0.5, 0);
	levelText.y = -120;
	self.addChild(levelText);
	var statDisplayContainer = new Container();
	statDisplayContainer.y = -40;
	var statsDisplay = new Text2('HP: ' + playerStats.maxHealth + ' | ATK: ' + playerStats.damage + ' | SPD: ' + playerStats.attackSpeed.toFixed(1), {
		size: 45,
		fill: 0xFFFFFF
	});
	statsDisplay.anchor.set(0.5, 0);
	statDisplayContainer.addChild(statsDisplay);
	self.addChild(statDisplayContainer);
	var statUpgrades = [{
		label: 'Health +20',
		key: 'maxHealth',
		value: 20,
		stat: 'playerStats.maxHealth',
		description: 'Increase maximum health'
	}, {
		label: 'Attack +10',
		key: 'damage',
		value: 10,
		stat: 'playerStats.damage',
		description: 'Boost damage output'
	}, {
		label: 'Speed +2',
		key: 'speed',
		value: 2,
		stat: 'playerStats.speed',
		description: 'Move faster'
	}, {
		label: 'Fire Rate +0.2',
		key: 'attackSpeed',
		value: 0.2,
		stat: 'playerStats.attackSpeed',
		description: 'Shoot more often'
	}];
	var abilityUpgrades = [{
		label: 'Aura Ability',
		key: 'auraAbility',
		value: 1,
		stat: 'auraAbility',
		description: 'Damage nearby enemies'
	}, {
		label: 'Spikes Armor',
		key: 'spikesArmor',
		value: 1,
		stat: 'spikesArmor',
		description: 'Reflect damage'
	}, {
		label: 'Dual Shot',
		key: 'dualShot',
		value: 1,
		stat: 'dualShot',
		description: 'Fire 2 projectiles'
	}, {
		label: 'Push Hand',
		key: 'pushHand',
		value: 1,
		stat: 'pushHand',
		description: 'Push enemies away'
	}, {
		//{ice_ability1}
		label: 'Ice Shot',
		//{ice_ability2}
		key: 'iceShot',
		//{ice_ability3}
		value: 1,
		//{ice_ability4}
		stat: 'iceShot',
		//{ice_ability5}
		description: 'Freeze enemies on impact' //{ice_ability6}
	}, {
		label: 'Wave Ability',
		key: 'waveAbility',
		value: 1,
		stat: 'waveAbility',
		description: 'Send a wave across the map'
	}, {
		//{meteor_panel1}
		label: 'Meteorite Ability',
		//{meteor_panel2}
		key: 'meteoriteAbility',
		//{meteor_panel3}
		value: 1,
		//{meteor_panel4}
		stat: 'meteoriteAbility',
		//{meteor_panel5}
		description: 'Rain meteors on enemies' //{meteor_panel6}
	}];
	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 = [];
	var buttonWidth = 280;
	var buttonHeight = 100;
	var buttonSpacingX = 320;
	var buttonSpacingY = 150;
	var startX = -160;
	var startY = 40;
	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;
		btn.tint = 0x6495ED;
		var labelText = new Text2(upgrades[i].label, {
			size: 38,
			fill: 0xFFFFFF
		});
		labelText.anchor.set(0.5, 0.3);
		btn.addChild(labelText);
		var descText = new Text2(upgrades[i].description, {
			size: 20,
			fill: 0xDDDDDD
		});
		descText.anchor.set(0.5, 0.7);
		btn.addChild(descText);
		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);
			self.applyUpgrade(self.buttons[randomIndex].upgradeKey, self.buttons[randomIndex].upgradeValue);
			closeLevelUpPanel();
		}, 5000);
	};
	self.cancelAutoSelect = function () {
		if (self.autoSelectTimer !== null) {
			LK.clearTimeout(self.autoSelectTimer);
			self.autoSelectTimer = null;
		}
	};
	self.applyUpgrade = function (key, value) {
		//{apply_upgrade_new}
		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();
			}
		} else if (key === 'pushHand') {
			if (!playerPushHand) {
				playerPushHand = new PushHand();
				game.addChild(playerPushHand);
				playerPushHand.x = player.x;
				playerPushHand.y = player.y;
			}
		} else if (key === 'iceShot') {
			//{ice_apply1}
			if (!playerIceShot) {
				//{ice_apply2}
				playerIceShot = new IceShot(); //{ice_apply3}
			} //{ice_apply4}
		} else if (key === 'waveAbility') {
			if (!playerWaveAbility) {
				playerWaveAbility = true;
				playerWaveAbilityCounter = 0;
			}
		} else if (key === 'meteoriteAbility') {
			//{meteor_ability1}
			if (!playerMeteoriteAbility) {
				//{meteor_ability2}
				playerMeteoriteAbility = true; //{meteor_ability3}
				playerMeteoriteCounter = 0; //{meteor_ability4}
			} //{meteor_ability5}
		}
	}; //{apply_upgrade_end}
	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();
				self.applyUpgrade(btn.upgradeKey, btn.upgradeValue);
				closeLevelUpPanel();
				break;
			}
		}
	};
	return self;
});
//{exp_pickup_23}
var Meteorite = Container.expand(function () {
	var self = Container.call(this);
	//{meteor_1}
	self.radius = 100; //{meteor_2}
	self.maxRadius = 300; //{meteor_3}
	self.expandSpeed = 8; //{meteor_4}
	self.damage = 40; //{meteor_5}
	self.burnDuration = 180; //{meteor_6}
	self.damageDealt = {}; //{meteor_7}
	var meteorGraphics = self.attachAsset('enemyProjectileSpiky', {
		anchorX: 0.5,
		//{meteor_8}
		anchorY: 0.5 //{meteor_9}
	}); //{meteor_10}
	meteorGraphics.tint = 0xFF4500;
	meteorGraphics.scaleX = 2;
	meteorGraphics.scaleY = 2;
	self.update = function () {
		//{meteor_11}
		if (self.radius < self.maxRadius) {
			self.radius += self.expandSpeed; //{meteor_12}
			self.scaleX = self.radius / 50; //{meteor_13}
			self.scaleY = self.radius / 50; //{meteor_14}
		} //{meteor_15}
		for (var i = 0; i < enemies.length; i++) {
			//{meteor_16}
			var enemy = enemies[i]; //{meteor_17}
			if (!enemy) continue; //{meteor_18}
			var distance = calculateDistance(self.x, self.y, enemy.x, enemy.y); //{meteor_19}
			if (distance < self.radius) {
				//{meteor_20}
				if (!self.damageDealt[i]) {
					enemy.health -= self.damage; //{meteor_21}
					enemy.healthBar.updateHealth(enemy.health); //{meteor_22}
					self.damageDealt[i] = true; //{meteor_23}
					if (enemy.health <= 0) {
						//{meteor_24}
						playerScore += 100; //{meteor_25}
						scoreText.setText('Score: ' + playerScore); //{meteor_26}
						playerExp += 25; //{meteor_27}
						if (playerExp >= expToNextLevel) {
							//{meteor_28}
							playerExp -= expToNextLevel; //{meteor_29}
							playerLevel += 1; //{meteor_30}
							expToNextLevel = Math.floor(expToNextLevel * 1.2); //{meteor_31}
							playerHealth += 20; //{meteor_32}
							showLevelUpPanel(); //{meteor_33}
						} //{meteor_34}
						enemy.destroy(); //{meteor_35}
						enemies.splice(i, 1); //{meteor_36}
					} //{meteor_37}
				} //{meteor_38}
			} //{meteor_39}
		} //{meteor_40}
		if (self.radius >= self.maxRadius) {
			self.destroy(); //{meteor_41}
		} //{meteor_42}
	}; //{meteor_43}
	return self; //{meteor_44}
});
//{meteor_45}
var Projectile = Container.expand(function () {
	var self = Container.call(this);
	var projectileGraphics = self.attachAsset('projectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	projectileGraphics.tint = 0xffff44;
	projectileGraphics.alpha = 0.9;
	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) {
					playerScore += 100;
					scoreText.setText('Score: ' + playerScore);
					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 (!enemyProjectiles[i].fromSkeleton && 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 PushHand = Container.expand(function () {
	var self = Container.call(this);
	self.radius = 400;
	self.pushForce = 15;
	self.tickCounter = 0;
	self.ticksPerPush = 30;
	self.lastPushFrame = {};
	var handGraphics = self.attachAsset('upgradeButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	handGraphics.scaleX = 0.5;
	handGraphics.scaleY = 0.5;
	handGraphics.tint = 0xFFFFFF;
	self.update = function () {
		self.tickCounter++;
		if (self.tickCounter >= self.ticksPerPush) {
			self.tickCounter = 0;
			var enemyCount = enemies.length;
			for (var i = 0; i < enemyCount; i++) {
				var enemy = enemies[i];
				var distance = calculateDistance(player.x, player.y, enemy.x, enemy.y);
				if (distance < self.radius && distance > 0) {
					var dx = enemy.x - player.x;
					var dy = enemy.y - player.y;
					var pushX = dx / distance * self.pushForce;
					var pushY = dy / distance * self.pushForce;
					enemy.x += pushX;
					enemy.y += pushY;
				}
			}
			var projectileCount = enemyProjectiles.length;
			for (var i = 0; i < projectileCount; i++) {
				var projectile = enemyProjectiles[i];
				var distance = calculateDistance(player.x, player.y, projectile.x, projectile.y);
				if (distance < self.radius && distance > 0) {
					var dx = projectile.x - player.x;
					var dy = projectile.y - player.y;
					var pushX = dx / distance * self.pushForce;
					var pushY = dy / distance * self.pushForce;
					projectile.x += pushX;
					projectile.y += pushY;
				}
			}
		}
	};
	return self;
});
var Skeleton = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('skeletonSquare', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	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.frozen = false; //{ice_skel1}
	self.freezeEndTime = 0; //{ice_skel2}
	self.update = function () {
		if (player) {
			var distance = calculateDistance(self.x, self.y, player.x, player.y);
			if (distance > self.attackRange + 100) {
				if (distance > 0) {
					var dx = player.x - self.x;
					var dy = player.y - self.y;
					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;
					projectile.fromSkeleton = true;
					var dx = player.x - self.x;
					var dy = player.y - self.y;
					var distToPlayer = distance;
					if (distToPlayer > 0) {
						projectile.directionX = dx / distToPlayer;
						projectile.directionY = dy / distToPlayer;
					} else {
						projectile.directionX = 0;
						projectile.directionY = 0;
					}
					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) {
					playerScore += 100;
					scoreText.setText('Score: ' + playerScore);
					playerExp += 50;
					if (playerExp >= expToNextLevel) {
						playerExp -= expToNextLevel;
						playerLevel += 1;
						expToNextLevel = Math.floor(expToNextLevel * 1.2);
						playerHealth += 20;
						showLevelUpPanel();
					}
					if (Math.random() < 0.2) {
						//{skeleton_health_drop}
						var healthPickup = new HealthPickup(); //{skeleton_health_drop2}
						healthPickup.x = self.x; //{skeleton_health_drop3}
						healthPickup.y = self.y; //{skeleton_health_drop4}
						healthPickups.push(healthPickup); //{skeleton_health_drop5}
						game.addChild(healthPickup); //{skeleton_health_drop6}
					} //{skeleton_health_drop7}
					if (Math.random() < 0.15) {
						//{armor_drop_skel_1}
						var armorPickup = new ArmorPickup(); //{armor_drop_skel_2}
						armorPickup.x = self.x; //{armor_drop_skel_3}
						armorPickup.y = self.y; //{armor_drop_skel_4}
						armorPickups.push(armorPickup); //{armor_drop_skel_5}
						game.addChild(armorPickup); //{armor_drop_skel_6}
					} //{armor_drop_skel_7}
					var expPickup = new ExpPickup(); //{skeleton_exp_drop1}
					expPickup.x = self.x; //{skeleton_exp_drop2}
					expPickup.y = self.y; //{skeleton_exp_drop3}
					var throwAngle = Math.random() * Math.PI * 2;
					var throwForce = 3 + Math.random() * 4;
					expPickup.velocityX = Math.cos(throwAngle) * throwForce;
					expPickup.velocityY = Math.sin(throwAngle) * throwForce - 5;
					expPickups.push(expPickup); //{skeleton_exp_drop4}
					game.addChild(expPickup); //{skeleton_exp_drop5}
					self.destroy();
					enemies.splice(enemies.indexOf(self), 1);
				}
			}
			if (playerHealth <= 0) {
				endGameAndSaveScore();
			}
		}
		self.lastWasIntersecting = currentIntersecting;
	};
	return self;
});
//{4M_health3}
var SpikesArmor = Container.expand(function () {
	var self = Container.call(this);
	self.reflectPercentage = 0.3;
	self.active = true;
	var spikeGraphics = self.attachAsset('spikesArmorSpikes', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	spikeGraphics.tint = 0xff5500;
	return self;
});
var WaveAbility = Container.expand(function () {
	var self = Container.call(this);
	//{wave_1}
	self.radius = 50; //{wave_2}
	self.maxRadius = 800; //{wave_3}
	self.speed = 15; //{wave_4}
	self.damage = 30; //{wave_5}
	self.pushForce = 20; //{wave_push_force}
	self.directionX = 1; //{wave_6}
	self.directionY = 0; //{wave_7}
	self.damageDealt = {}; //{wave_8}
	self.pushedEnemies = {}; //{wave_pushed_enemies}
	var waveGraphics = self.attachAsset('waveEffect', {
		//{wave_9}
		anchorX: 0.5,
		//{wave_10}
		anchorY: 0.5 //{wave_11}
	}); //{wave_12}
	waveGraphics.tint = 0x00ff44; //{wave_13}
	waveGraphics.alpha = 0.7;
	self.update = function () {
		//{wave_14}
		self.radius += self.speed; //{wave_15}
		self.scaleX = self.radius / 50; //{wave_16}
		self.scaleY = self.radius / 50; //{wave_17}
		self.x += self.directionX * self.speed; //{wave_18}
		self.y += self.directionY * self.speed; //{wave_19}
		for (var i = 0; i < enemies.length; i++) {
			//{wave_20}
			var enemy = enemies[i]; //{wave_21}
			if (!enemy) continue; //{wave_22}
			var distance = calculateDistance(self.x, self.y, enemy.x, enemy.y); //{wave_23}
			if (distance < self.radius) {
				//{wave_push_start}
				if (!self.pushedEnemies[i]) {
					var dx = enemy.x - self.x;
					var dy = enemy.y - self.y;
					if (distance > 0) {
						var pushX = dx / distance * self.pushForce;
						var pushY = dy / distance * self.pushForce;
						enemy.x += pushX;
						enemy.y += pushY;
					}
					self.pushedEnemies[i] = true;
				}
				//{wave_push_end}
				if (!self.damageDealt[i]) {
					//{wave_24}
					enemy.health -= self.damage; //{wave_25}
					enemy.healthBar.updateHealth(enemy.health); //{wave_26}
					self.damageDealt[i] = true; //{wave_27}
					if (enemy.health <= 0) {
						//{wave_28}
						playerScore += 100; //{wave_29}
						scoreText.setText('Score: ' + playerScore); //{wave_30}
						playerExp += 25; //{wave_31}
						if (playerExp >= expToNextLevel) {
							//{wave_32}
							playerExp -= expToNextLevel; //{wave_33}
							playerLevel += 1; //{wave_34}
							expToNextLevel = Math.floor(expToNextLevel * 1.2); //{wave_35}
							playerHealth += 20; //{wave_36}
							showLevelUpPanel(); //{wave_37}
						} //{wave_38}
						enemy.destroy(); //{wave_39}
						enemies.splice(i, 1); //{wave_40}
					} //{wave_41}
				}
			} //{wave_42}
		} //{wave_43}
		if (self.radius > self.maxRadius || self.x < -100 || self.x > 2148 || self.y < -100 || self.y > 2832) {
			//{wave_44}
			self.destroy(); //{wave_45}
		} //{wave_46}
	}; //{wave_47}
	return self; //{wave_48}
});
//{wave_49}
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.frozen = false; //{ice_zomb1}
	self.freezeEndTime = 0; //{ice_zomb2}
	self.update = function () {
		if (player) {
			var distance = calculateDistance(self.x, self.y, player.x, player.y);
			if (distance > 0) {
				var dx = player.x - self.x;
				var dy = player.y - self.y;
				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) {
					playerScore += 100;
					scoreText.setText('Score: ' + playerScore);
					playerExp += 25;
					if (playerExp >= expToNextLevel) {
						playerExp -= expToNextLevel;
						playerLevel += 1;
						expToNextLevel = Math.floor(expToNextLevel * 1.2);
						playerHealth += 20;
						showLevelUpPanel();
					}
					if (Math.random() < 0.2) {
						//{zombie_health_drop}
						var healthPickup = new HealthPickup(); //{zombie_health_drop2}
						healthPickup.x = self.x; //{zombie_health_drop3}
						healthPickup.y = self.y; //{zombie_health_drop4}
						healthPickups.push(healthPickup); //{zombie_health_drop5}
						game.addChild(healthPickup); //{zombie_health_drop6}
					} //{zombie_health_drop7}
					if (Math.random() < 0.15) {
						//{armor_drop_1}
						var armorPickup = new ArmorPickup(); //{armor_drop_2}
						armorPickup.x = self.x; //{armor_drop_3}
						armorPickup.y = self.y; //{armor_drop_4}
						armorPickups.push(armorPickup); //{armor_drop_5}
						game.addChild(armorPickup); //{armor_drop_6}
					} //{armor_drop_7}
					var expPickup = new ExpPickup(); //{zombie_exp_drop1}
					expPickup.x = self.x; //{zombie_exp_drop2}
					expPickup.y = self.y; //{zombie_exp_drop3}
					var throwAngle = Math.random() * Math.PI * 2;
					var throwForce = 3 + Math.random() * 4;
					expPickup.velocityX = Math.cos(throwAngle) * throwForce;
					expPickup.velocityY = Math.sin(throwAngle) * throwForce - 5;
					expPickups.push(expPickup); //{zombie_exp_drop4}
					game.addChild(expPickup); //{zombie_exp_drop5}
					self.destroy();
					enemies.splice(enemies.indexOf(self), 1);
				}
			}
			if (playerHealth <= 0) {
				endGameAndSaveScore();
			}
		}
		self.lastWasIntersecting = currentIntersecting;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
/**** 
* Helper Functions
****/ 
function calculateDistance(x1, y1, x2, y2) {
	var dx = x2 - x1;
	var dy = y2 - y1;
	return Math.sqrt(dx * dx + dy * dy);
}
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 playerArmor = 50;
var playerExp = 0;
var playerLevel = 1;
var expToNextLevel = 100;
var enemies = [];
var projectiles = [];
var enemyProjectiles = [];
var healthPickups = [];
var armorPickups = [];
var expPickups = [];
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 armorText = new Text2('Armor: ' + playerArmor, {
	size: 60,
	//{armor_ui_1}
	fill: 0xcccccc //{armor_ui_2}
}); //{armor_ui_3}
armorText.anchor.set(0.5, 0);
armorText.y = 70;
LK.gui.top.addChild(armorText);
var expText = new Text2('Level: ' + playerLevel + ' | EXP: ' + playerExp + '/' + expToNextLevel, {
	size: 50,
	fill: 0x00FF00
});
expText.anchor.set(0.5, 0);
expText.y = 140;
LK.gui.top.addChild(expText);
var playerScore = 0;
var scoreText = new Text2('Score: ' + playerScore, {
	size: 60,
	fill: 0xFFFF00
});
scoreText.anchor.set(0.5, 0);
scoreText.y = 210;
LK.gui.top.addChild(scoreText);
var topScoreText = new Text2('Top Score: ' + storage.topScore, {
	size: 50,
	fill: 0xFFA500
});
topScoreText.anchor.set(0.5, 0);
topScoreText.y = 280;
LK.gui.top.addChild(topScoreText);
var levelUpPanel = null;
var playerStats = {
	maxHealth: 100,
	maxArmor: 100,
	attackSpeed: 1.0,
	damage: 25,
	speed: 8
};
var playerAuraAbility = null;
var playerSpikesArmor = null;
var playerDualShot = null;
var playerPushHand = null;
var playerIceShot = null; //{ice_global1}
var playerWaveAbility = false;
var playerWaveAbilityCounter = 0;
var playerMeteoriteAbility = false;
var playerMeteoriteCounter = 0;
var meteorites = []; //{meteor_global1}
var chests = [];
var inventoryPanel = null;
inventoryPanel = new InventoryPanel(); //{inv_init1}
game.addChild(inventoryPanel); //{inv_init2}
inventoryPanel.spawnChests(); //{inv_init3}
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;
	}
}
function endGameAndSaveScore() {
	if (playerScore > storage.topScore) {
		storage.topScore = playerScore;
		topScoreText.setText('Top Score: ' + storage.topScore);
	}
	LK.showGameOver();
}
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 % 3000 === 0) {
		var angle = Math.random() * Math.PI * 2; //{chest_spawn1}
		var distance = 800;
		var chestX = player.x + Math.cos(angle) * distance; //{chest_spawn2}
		var chestY = player.y + Math.sin(angle) * distance; //{chest_spawn3}
		chestX = Math.max(100, Math.min(chestX, 1948));
		chestY = Math.max(100, Math.min(chestY, 2632)); //{chest_spawn4}
		var newChest = new Chest(); //{chest_spawn5}
		newChest.x = chestX;
		newChest.y = chestY; //{chest_spawn6}
		chests.push(newChest); //{chest_spawn7}
		game.addChild(newChest); //{chest_spawn8}
	} //{chest_spawn9}
	if (playerWaveAbility) {
		playerWaveAbilityCounter++;
		if (playerWaveAbilityCounter >= 240) {
			playerWaveAbilityCounter = 0;
			var directionX = 0;
			var directionY = 0;
			if (enemies.length > 0) {
				var clusterX = 0;
				var clusterY = 0;
				for (var i = 0; i < enemies.length; i++) {
					clusterX += enemies[i].x;
					clusterY += enemies[i].y;
				}
				clusterX /= enemies.length;
				clusterY /= enemies.length;
				var dx = clusterX - player.x;
				var dy = clusterY - player.y;
				var clusterDistance = Math.sqrt(dx * dx + dy * dy);
				if (clusterDistance > 0) {
					directionX = dx / clusterDistance;
					directionY = dy / clusterDistance;
				} else {
					directionX = 1;
					directionY = 0;
				}
			} else {
				var angle = Math.random() * Math.PI * 2;
				directionX = Math.cos(angle);
				directionY = Math.sin(angle);
			}
			var wave = new WaveAbility();
			wave.x = player.x;
			wave.y = player.y;
			wave.directionX = directionX;
			wave.directionY = directionY;
			game.addChild(wave);
		}
	}
	if (playerMeteoriteAbility) {
		//{meteor_spawn1}
		playerMeteoriteCounter++; //{meteor_spawn2}
		if (playerMeteoriteCounter >= 180) {
			//{meteor_spawn3}
			playerMeteoriteCounter = 0; //{meteor_spawn4}
			if (enemies.length > 0) {
				//{meteor_spawn5}
				var randomEnemyIndex = Math.floor(Math.random() * enemies.length); //{meteor_spawn6}
				var targetEnemy = enemies[randomEnemyIndex]; //{meteor_spawn7}
				var meteorite = new Meteorite(); //{meteor_spawn8}
				meteorite.x = targetEnemy.x; //{meteor_spawn9}
				meteorite.y = targetEnemy.y; //{meteor_spawn10}
				meteorites.push(meteorite); //{meteor_spawn11}
				game.addChild(meteorite); //{meteor_spawn12}
			} //{meteor_spawn13}
		} //{meteor_spawn14}
	} //{meteor_spawn15}
	if (LK.ticks % 30 === 0 && enemies.length > 0) {
		if (playerIceShot) {
			//{ice_fire1}
			playerIceShot.fireProjectiles(player.x, player.y, enemies);
		} else if (playerDualShot) {
			playerDualShot.fireProjectiles(player.x, player.y, enemies);
		} else {
			var closestEnemy = null;
			var closestDistance = Infinity;
			var enemyCount = enemies.length;
			for (var i = 0; i < enemyCount; i++) {
				var distance = calculateDistance(player.x, player.y, enemies[i].x, enemies[i].y);
				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 = 0; i < enemies.length; i++) {
		//{ice_freeze1}
		var enemy = enemies[i]; //{ice_freeze2}
		if (enemy.frozen && enemy.freezeEndTime <= LK.ticks) {
			//{ice_freeze3}
			enemy.frozen = false; //{ice_freeze4}
			enemy.tint = 0xFFFFFF; //{ice_freeze5}
		} //{ice_freeze6}
		if (enemy.frozen) {
			//{ice_freeze7}
			enemy.speed = 0; //{ice_freeze8}
		} else if (enemy.constructor.name === 'Skeleton') {
			//{ice_freeze9}
			enemy.speed = 1.5; //{ice_freeze10}
		} else {
			//{ice_freeze11}
			enemy.speed = 2; //{ice_freeze12}
		} //{ice_freeze13}
	} //{ice_freeze14}
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		var distance = calculateDistance(player.x, player.y, enemy.x, enemy.y);
		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();
	}
	for (var i = armorPickups.length - 1; i >= 0; i--) {
		//{armor_update_1}
		armorPickups[i].update(); //{armor_update_2}
	} //{armor_update_3}
	for (var i = expPickups.length - 1; i >= 0; i--) {
		//{exp_update1}
		expPickups[i].update(); //{exp_update2}
	} //{exp_update3}
	for (var i = chests.length - 1; i >= 0; i--) {
		//{chest_update1}
		if (chests[i].opened) {
			//{chest_update2}
			chests[i].destroy();
			chests.splice(i, 1);
		} else {
			chests[i].update();
		} //{chest_update3}
	} //{chest_update4}
	for (var i = meteorites.length - 1; i >= 0; i--) {
		//{meteor_update1}
		meteorites[i].update(); //{meteor_update2}
	} //{meteor_update3}
	if (playerPushHand) {
		//{push_update1}
		playerPushHand.x = player.x;
		playerPushHand.y = player.y;
		playerPushHand.update();
	} //{push_update2}
	healthText.setText('Health: ' + playerHealth);
	armorText.setText('Armor: ' + playerArmor);
	expText.setText('Level: ' + playerLevel + ' | EXP: ' + playerExp + '/' + expToNextLevel);
};
//{meteor_45}