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

/**** 
* Classes
****/ 
var BaseBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('baseBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 10;
	self.damage = 20;
	self.targetX = 0;
	self.targetY = 0;
	self.directionX = 0;
	self.directionY = 0;
	self.setTarget = function (x, y) {
		self.targetX = x;
		self.targetY = y;
		var dx = x - self.x;
		var dy = y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.directionX = dx / distance;
			self.directionY = dy / distance;
		}
	};
	self.update = function () {
		self.x += self.directionX * self.speed;
		self.y += self.directionY * self.speed;
	};
	return self;
});
var BaseTurret = Container.expand(function () {
	var self = Container.call(this);
	var turretGraphics = self.attachAsset('baseTurret', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.lastShot = 0;
	self.shootCooldown = 400;
	self.range = 350;
	self.damage = 45;
	self.findNearestEnemy = function () {
		var nearestEnemy = null;
		var nearestDistance = Infinity;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < nearestDistance && distance <= self.range) {
				nearestDistance = distance;
				nearestEnemy = enemy;
			}
		}
		return nearestEnemy;
	};
	self.shootAtEnemy = function (target) {
		var bullet = new BaseBullet();
		bullet.x = self.x;
		bullet.y = self.y;
		bullet.setTarget(target.x, target.y);
		bullet.damage = self.damage;
		baseBullets.push(bullet);
		game.addChild(bullet);
		LK.getSound('shoot').play();
	};
	self.update = function () {
		if (LK.ticks - self.lastShot > self.shootCooldown / 16.67) {
			var target = self.findNearestEnemy();
			if (target) {
				self.shootAtEnemy(target);
				self.lastShot = LK.ticks;
				var angle = Math.atan2(target.y - self.y, target.x - self.x);
				turretGraphics.rotation = angle;
			}
		}
	};
	return self;
});
var Bear = Container.expand(function () {
	var self = Container.call(this);
	var bearGraphics = self.attachAsset('bear', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 1.8;
	self.damage = 70;
	self.health = 200;
	self.maxHealth = 200;
	self.chargeTimer = 0;
	self.isCharging = false;
	self.takeDamage = function (damage) {
		self.health -= damage;
		// Create blood splatter effect
		createBloodSplatter(self.x, self.y, Math.min(damage / 12, 8));
		tween(bearGraphics, {
			tint: 0xff0000
		}, {
			duration: 100
		});
		tween(bearGraphics, {
			tint: 0xffffff
		}, {
			duration: 100
		});
		if (self.health <= 0) {
			// Create larger blood splatter when dying
			createBloodSplatter(self.x, self.y, 12);
			return true;
		}
		return false;
	};
	self.update = function () {
		var dx = hero.x - self.x;
		var dy = hero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.chargeTimer++;
			if (self.chargeTimer > 100 && !self.isCharging) {
				self.isCharging = true;
				self.chargeTimer = 0;
				tween(bearGraphics, {
					tint: 0x8B4513
				}, {
					duration: 300
				});
				tween(self, {
					x: self.x + dx / distance * self.speed * 10,
					y: self.y + dy / distance * self.speed * 10
				}, {
					duration: 700,
					onFinish: function onFinish() {
						self.isCharging = false;
						tween(bearGraphics, {
							tint: 0xffffff
						}, {
							duration: 300
						});
					}
				});
			} else if (!self.isCharging) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
	};
	return self;
});
var BloodParticle = Container.expand(function () {
	var self = Container.call(this);
	var bloodGraphics = self.attachAsset('baseBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bloodGraphics.tint = 0x8B0000; // Dark red color
	bloodGraphics.scaleX = 0.3;
	bloodGraphics.scaleY = 0.3;
	self.velocityX = (Math.random() - 0.5) * 8;
	self.velocityY = (Math.random() - 0.5) * 8;
	self.gravity = 0.2;
	self.life = 60; // 1 second at 60fps
	self.maxLife = 60;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		self.velocityY += self.gravity;
		self.life--;
		// Fade out over time
		var alpha = self.life / self.maxLife;
		bloodGraphics.alpha = alpha;
	};
	return self;
});
var BloodTrail = Container.expand(function () {
	var self = Container.call(this);
	var trailGraphics = self.attachAsset('baseBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	trailGraphics.tint = 0x8B0000; // Dark red color
	trailGraphics.scaleX = 0.4; // Make trails twice as wide
	trailGraphics.scaleY = 1.2; // Make trails twice as long
	self.life = 360; // 6 seconds at 60fps - double duration
	self.maxLife = 360;
	self.fadeSpeed = 0.002; // Slower fade for more visible trails
	self.update = function () {
		self.life--;
		// Fade out over time
		var alpha = self.life / self.maxLife;
		trailGraphics.alpha = alpha * 0.7;
		// Scale down over time
		var scale = alpha * 0.6;
		trailGraphics.scaleX = 0.2 * scale;
		trailGraphics.scaleY = 0.6 * scale;
	};
	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 = 12;
	self.damage = 35;
	self.targetX = 0;
	self.targetY = 0;
	self.directionX = 0;
	self.directionY = 0;
	self.setTarget = function (x, y) {
		self.targetX = x;
		self.targetY = y;
		var dx = x - self.x;
		var dy = y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.directionX = dx / distance;
			self.directionY = dy / distance;
		}
	};
	self.update = function () {
		self.x += self.directionX * self.speed;
		self.y += self.directionY * self.speed;
	};
	return self;
});
var ControlledAnimal = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'sheep';
	self.speed = 3;
	self.damage = 30;
	self.health = 100;
	self.maxHealth = 100;
	var animalGraphics = self.attachAsset('controlledAnimal', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x00ffff
	});
	self.takeDamage = function (damage) {
		self.health -= damage;
		// Create blood splatter effect
		createBloodSplatter(self.x, self.y, Math.min(damage / 8, 6));
		tween(animalGraphics, {
			tint: 0xff0000
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(animalGraphics, {
					tint: 0x00ffff
				}, {
					duration: 100
				});
			}
		});
		if (self.health <= 0) {
			// Create blood splatter when dying
			createBloodSplatter(self.x, self.y, 10);
			return true;
		}
		return false;
	};
	self.attackEnemies = function () {
		var attackRange = 100;
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			if (enemy.type === self.type) continue; // Don't attack same type
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= attackRange) {
				var enemyDied = enemy.takeDamage(self.damage);
				if (enemyDied) {
					LK.setScore(LK.getScore() + 15);
					scoreTxt.setText('Score: ' + LK.getScore());
					enemy.destroy();
					enemies.splice(i, 1);
				}
			}
		}
	};
	self.update = function () {
		// Attack nearby enemies of different types
		if (LK.ticks % 30 === 0) {
			self.attackEnemies();
		}
	};
	return self;
});
var Eagle = Container.expand(function () {
	var self = Container.call(this);
	var eagleGraphics = self.attachAsset('eagle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 4.0;
	self.damage = 40;
	self.health = 80;
	self.maxHealth = 80;
	self.swoopTimer = 0;
	self.isSwooping = false;
	self.flightPattern = 0;
	self.takeDamage = function (damage) {
		self.health -= damage;
		tween(eagleGraphics, {
			tint: 0xff0000
		}, {
			duration: 100
		});
		tween(eagleGraphics, {
			tint: 0xffffff
		}, {
			duration: 100
		});
		if (self.health <= 0) {
			return true;
		}
		return false;
	};
	self.update = function () {
		var dx = hero.x - self.x;
		var dy = hero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.swoopTimer++;
			self.flightPattern++;
			if (self.swoopTimer > 80 && !self.isSwooping) {
				self.isSwooping = true;
				self.swoopTimer = 0;
				tween(self, {
					x: hero.x,
					y: hero.y
				}, {
					duration: 600,
					onFinish: function onFinish() {
						self.isSwooping = false;
					}
				});
			} else if (!self.isSwooping) {
				var circleX = hero.x + Math.cos(self.flightPattern * 0.05) * 150;
				var circleY = hero.y + Math.sin(self.flightPattern * 0.05) * 150;
				self.x += (circleX - self.x) * 0.02;
				self.y += (circleY - self.y) * 0.02;
			}
		}
	};
	return self;
});
var Elephant = Container.expand(function () {
	var self = Container.call(this);
	var elephantGraphics = self.attachAsset('elephant', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 1.5;
	self.damage = 80;
	self.health = 250;
	self.maxHealth = 250;
	self.trampleTimer = 0;
	self.isTrampling = false;
	self.takeDamage = function (damage) {
		self.health -= damage;
		tween(elephantGraphics, {
			tint: 0xff0000
		}, {
			duration: 100
		});
		tween(elephantGraphics, {
			tint: 0xffffff
		}, {
			duration: 100
		});
		if (self.health <= 0) {
			return true;
		}
		return false;
	};
	self.update = function () {
		var dx = hero.x - self.x;
		var dy = hero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.trampleTimer++;
			if (self.trampleTimer > 120 && !self.isTrampling) {
				self.isTrampling = true;
				self.trampleTimer = 0;
				LK.effects.flashScreen(0x8B4513, 200);
				tween(self, {
					x: self.x + dx / distance * self.speed * 8,
					y: self.y + dy / distance * self.speed * 8
				}, {
					duration: 1000,
					onFinish: function onFinish() {
						self.isTrampling = false;
					}
				});
			} else if (!self.isTrampling) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
	};
	return self;
});
var Enemy = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'sheep';
	self.speed = 1;
	self.damage = 10;
	self.health = 30;
	self.maxHealth = 30;
	var enemyGraphics;
	if (self.type === 'sheep') {
		enemyGraphics = self.attachAsset('sheep', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 1.5;
		self.damage = 12;
		self.health = 30;
		self.maxHealth = 30;
	} else if (self.type === 'cow') {
		enemyGraphics = self.attachAsset('cow', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 1.2;
		self.damage = 35;
		self.health = 100;
		self.maxHealth = 100;
	} else if (self.type === 'chicken') {
		enemyGraphics = self.attachAsset('chicken', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 4.2;
		self.damage = 12;
		self.health = 35;
		self.maxHealth = 35;
	} else if (self.type === 'chick') {
		enemyGraphics = self.attachAsset('chick', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 4;
		self.damage = 8;
		self.health = 20;
		self.maxHealth = 20;
	} else if (self.type === 'snake') {
		enemyGraphics = self.attachAsset('snake', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 2.2;
		self.damage = 28;
		self.health = 50;
		self.maxHealth = 50;
		self.zigzagTimer = 0;
		self.zigzagDirection = 1;
	} else if (self.type === 'mouse') {
		enemyGraphics = self.attachAsset('mouse', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 5;
		self.damage = 10;
		self.health = 25;
		self.maxHealth = 25;
		self.jumpTimer = 0;
		self.isJumping = false;
	} else if (self.type === 'hyperSheep') {
		enemyGraphics = self.attachAsset('hyperSheep', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 3.5;
		self.damage = 18;
		self.health = 60;
		self.maxHealth = 60;
		self.chargeTimer = 0;
		self.isCharging = false;
	} else if (self.type === 'hyperCow') {
		enemyGraphics = self.attachAsset('hyperCow', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 2.5;
		self.damage = 25;
		self.health = 70;
		self.maxHealth = 70;
		self.rageMode = false;
		self.rageDuration = 0;
	} else if (self.type === 'hyperChicken') {
		enemyGraphics = self.attachAsset('hyperChicken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 2,
			scaleY: 2
		});
		self.speed = 2.5;
		self.damage = 15;
		self.health = 120;
		self.maxHealth = 120;
		self.flightTimer = 0;
		self.isFlying = false;
		self.isBoss = true;
	} else if (self.type === 'pig') {
		enemyGraphics = self.attachAsset('pig', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 1.5;
		self.damage = 22;
		self.health = 70;
		self.maxHealth = 70;
		self.rollTimer = 0;
		self.isRolling = false;
	} else if (self.type === 'goat') {
		enemyGraphics = self.attachAsset('goat', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 2.8;
		self.damage = 32;
		self.health = 85;
		self.maxHealth = 85;
		self.headbuttTimer = 0;
	} else if (self.type === 'duck') {
		enemyGraphics = self.attachAsset('duck', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 3.2;
		self.damage = 18;
		self.health = 40;
		self.maxHealth = 40;
		self.quackTimer = 0;
	} else if (self.type === 'rabbit') {
		enemyGraphics = self.attachAsset('rabbit', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.speed = 4.5;
		self.damage = 15;
		self.health = 30;
		self.maxHealth = 30;
		self.hopTimer = 0;
	} else if (self.type === 'omegaSheep') {
		enemyGraphics = self.attachAsset('omegaSheep', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.5,
			scaleY: 1.5
		});
		self.speed = 3.5;
		self.damage = 15;
		self.health = 50;
		self.maxHealth = 50;
		self.omegaTimer = 0;
		self.isOmega = true;
	} else if (self.type === 'omegaCow') {
		enemyGraphics = self.attachAsset('omegaCow', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.5,
			scaleY: 1.5
		});
		self.speed = 3.2;
		self.damage = 20;
		self.health = 60;
		self.maxHealth = 60;
		self.omegaTimer = 0;
		self.isOmega = true;
	} else if (self.type === 'omegaChicken') {
		enemyGraphics = self.attachAsset('omegaChicken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.5,
			scaleY: 1.5
		});
		self.speed = 4.0;
		self.damage = 15;
		self.health = 45;
		self.maxHealth = 45;
		self.omegaTimer = 0;
		self.isOmega = true;
	} else if (self.type === 'omegaPig') {
		enemyGraphics = self.attachAsset('omegaPig', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.5,
			scaleY: 1.5
		});
		self.speed = 3.5;
		self.damage = 18;
		self.health = 55;
		self.maxHealth = 55;
		self.omegaTimer = 0;
		self.isOmega = true;
	} else if (self.type === 'windBoss') {
		enemyGraphics = self.attachAsset('windBoss', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.8,
			scaleY: 1.8
		});
		self.speed = 3.0;
		self.damage = 25;
		self.health = 80;
		self.maxHealth = 80;
		self.windTimer = 0;
		self.isBoss = true;
		self.windPushTimer = 0;
	} else if (self.type === 'magmaBoss') {
		enemyGraphics = self.attachAsset('magmaBoss', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.9,
			scaleY: 1.9
		});
		self.speed = 2.5;
		self.damage = 30;
		self.health = 90;
		self.maxHealth = 90;
		self.magmaTimer = 0;
		self.isBoss = true;
		self.lavaSprayTimer = 0;
	}
	self.takeDamage = function (damage) {
		self.health -= damage;
		// Mark as wounded to start blood trail
		self.isWounded = true;
		self.lastTrailX = self.x;
		self.lastTrailY = self.y;
		self.trailTimer = 0;
		// Create blood splatter effect
		createBloodSplatter(self.x, self.y, Math.min(damage / 6, 15));
		// Add extra blood spray for critical hits
		if (damage >= 40) {
			createBloodSplatter(self.x, self.y, 20);
			LK.effects.flashObject(self, 0xff0000, 200);
		}
		// Create initial blood trail
		createBloodTrail(self.x, self.y);
		// Flash red when hit
		tween(enemyGraphics, {
			tint: 0xff0000
		}, {
			duration: 100
		});
		tween(enemyGraphics, {
			tint: 0xffffff
		}, {
			duration: 100
		});
		if (self.health <= 0) {
			// Create bigger blood splatter when dying
			createBloodSplatter(self.x, self.y, 12);
			return true; // Enemy died
		}
		return false;
	};
	self.update = function () {
		// Move towards hero
		var dx = hero.x - self.x;
		var dy = hero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Create blood trail if wounded and moving
		if (self.isWounded) {
			self.trailTimer = self.trailTimer || 0;
			self.trailTimer++;
			if (self.trailTimer > 3) {
				// Create trail every 3 frames for more blood
				var moveDistance = Math.sqrt((self.x - (self.lastTrailX || self.x)) * (self.x - (self.lastTrailX || self.x)) + (self.y - (self.lastTrailY || self.y)) * (self.y - (self.lastTrailY || self.y)));
				if (moveDistance > 8) {
					// Create multiple trails for heavier bleeding
					createBloodTrail(self.x, self.y);
					if (self.health <= self.maxHealth * 0.3) {
						// Heavy bleeding when severely wounded
						createBloodTrail(self.x + (Math.random() - 0.5) * 15, self.y + (Math.random() - 0.5) * 15);
						createBloodTrail(self.x + (Math.random() - 0.5) * 15, self.y + (Math.random() - 0.5) * 15);
					}
					self.lastTrailX = self.x;
					self.lastTrailY = self.y;
					self.trailTimer = 0;
				}
			}
		}
		if (distance > 0) {
			if (self.type === 'snake') {
				// Snake moves in zigzag pattern
				self.zigzagTimer++;
				if (self.zigzagTimer > 20) {
					self.zigzagDirection *= -1;
					self.zigzagTimer = 0;
				}
				var zigzagOffset = self.zigzagDirection * 30;
				self.x += dx / distance * self.speed + zigzagOffset * 0.02;
				self.y += dy / distance * self.speed;
			} else if (self.type === 'mouse') {
				// Mouse jumps towards hero
				self.jumpTimer++;
				if (self.jumpTimer > 40 && !self.isJumping) {
					self.isJumping = true;
					self.jumpTimer = 0;
					// Quick jump movement
					tween(self, {
						x: self.x + dx / distance * self.speed * 8,
						y: self.y + dy / distance * self.speed * 8
					}, {
						duration: 300,
						onComplete: function onComplete() {
							self.isJumping = false;
						}
					});
				} else if (!self.isJumping) {
					// Slow movement when not jumping
					self.x += dx / distance * (self.speed * 0.3);
					self.y += dy / distance * (self.speed * 0.3);
				}
			} else if (self.type === 'hyperSheep') {
				// HyperSheep charges at hero periodically
				self.chargeTimer++;
				if (self.chargeTimer > 60 && !self.isCharging) {
					self.isCharging = true;
					self.chargeTimer = 0;
					// Charge attack with visual effect
					tween(enemyGraphics, {
						tint: 0xff0000
					}, {
						duration: 200
					});
					tween(self, {
						x: self.x + dx / distance * self.speed * 12,
						y: self.y + dy / distance * self.speed * 12
					}, {
						duration: 500,
						onFinish: function onFinish() {
							self.isCharging = false;
							tween(enemyGraphics, {
								tint: 0xffffff
							}, {
								duration: 200
							});
						}
					});
				} else if (!self.isCharging) {
					self.x += dx / distance * self.speed;
					self.y += dy / distance * self.speed;
				}
			} else if (self.type === 'hyperCow') {
				// HyperCow enters rage mode when low health
				if (self.health <= self.maxHealth * 0.3 && !self.rageMode) {
					self.rageMode = true;
					self.rageDuration = 5000;
					self.speed *= 2;
					self.damage *= 1.5;
					tween(enemyGraphics, {
						tint: 0xff4400
					}, {
						duration: 300
					});
				}
				if (self.rageMode) {
					self.rageDuration -= 16.67;
					if (self.rageDuration <= 0) {
						self.rageMode = false;
						self.speed /= 2;
						self.damage /= 1.5;
						tween(enemyGraphics, {
							tint: 0xffffff
						}, {
							duration: 300
						});
					}
				}
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			} else if (self.type === 'hyperChicken') {
				// HyperChicken flies in aerial patterns
				self.flightTimer++;
				if (self.flightTimer > 120 && !self.isFlying) {
					self.isFlying = true;
					self.flightTimer = 0;
					// Aerial dive attack
					tween(self, {
						x: hero.x,
						y: hero.y - 100
					}, {
						duration: 800,
						onFinish: function onFinish() {
							tween(self, {
								x: hero.x,
								y: hero.y
							}, {
								duration: 400,
								onFinish: function onFinish() {
									self.isFlying = false;
								}
							});
						}
					});
				} else if (!self.isFlying) {
					// Circle around hero
					var angle = Math.atan2(dy, dx) + Math.sin(LK.ticks * 0.05) * 0.5;
					self.x += Math.cos(angle) * self.speed;
					self.y += Math.sin(angle) * self.speed;
				}
			} else if (self.type === 'pig') {
				// Pig rolls towards hero
				self.rollTimer++;
				if (self.rollTimer > 80 && !self.isRolling) {
					self.isRolling = true;
					self.rollTimer = 0;
					tween(self, {
						x: self.x + dx / distance * self.speed * 6,
						y: self.y + dy / distance * self.speed * 6
					}, {
						duration: 600,
						onFinish: function onFinish() {
							self.isRolling = false;
						}
					});
				} else if (!self.isRolling) {
					self.x += dx / distance * self.speed * 0.5;
					self.y += dy / distance * self.speed * 0.5;
				}
			} else if (self.type === 'goat') {
				// Goat charges with headbutt
				self.headbuttTimer++;
				if (self.headbuttTimer > 70) {
					self.headbuttTimer = 0;
					var angle = Math.atan2(dy, dx);
					self.x += Math.cos(angle) * self.speed * 2;
					self.y += Math.sin(angle) * self.speed * 2;
				} else {
					self.x += dx / distance * self.speed;
					self.y += dy / distance * self.speed;
				}
			} else if (self.type === 'duck') {
				// Duck waddles in wavy pattern
				self.quackTimer++;
				var waveOffset = Math.sin(self.quackTimer * 0.1) * 20;
				self.x += dx / distance * self.speed + waveOffset * 0.02;
				self.y += dy / distance * self.speed;
			} else if (self.type === 'rabbit') {
				// Rabbit hops quickly
				self.hopTimer++;
				if (self.hopTimer > 25) {
					self.hopTimer = 0;
					self.x += dx / distance * self.speed * 2;
					self.y += dy / distance * self.speed * 2;
				} else {
					self.x += dx / distance * self.speed * 0.3;
					self.y += dy / distance * self.speed * 0.3;
				}
			} else if (self.type === 'windBoss') {
				// Wind boss creates wind gusts and pushes hero
				self.windTimer++;
				self.windPushTimer++;
				if (self.windTimer > 200) {
					self.windTimer = 0;
					// Create wind gust effect
					LK.effects.flashScreen(0x87ceeb, 300);
					// Teleport in swirling pattern
					var angle = LK.ticks * 0.1;
					self.x = hero.x + Math.cos(angle) * 200;
					self.y = hero.y + Math.sin(angle) * 200;
				}
				// Push hero away periodically
				if (self.windPushTimer > 120 && distance < 300) {
					self.windPushTimer = 0;
					var pushForce = 30;
					hero.x += dx / distance * -pushForce; // Push away from boss
					hero.y += dy / distance * -pushForce;
					// Keep hero in bounds
					hero.x = Math.max(40, Math.min(2048 - 40, hero.x));
					hero.y = Math.max(40, Math.min(2732 - 40, hero.y));
					LK.getSound('windevent').play();
				}
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			} else if (self.type === 'magmaBoss') {
				// Magma boss creates lava sprays and fire effects
				self.magmaTimer++;
				self.lavaSprayTimer++;
				if (self.magmaTimer > 240) {
					self.magmaTimer = 0;
					// Create magma eruption effect - reduced intensity
					LK.effects.flashScreen(0xff4500, 200);
					// Create blood splatters to simulate lava spray - reduced intensity
					createBloodSplatter(self.x, self.y, 12);
					tween(enemyGraphics, {
						tint: 0xffff00
					}, {
						duration: 200,
						onFinish: function onFinish() {
							tween(enemyGraphics, {
								tint: 0xffffff
							}, {
								duration: 200
							});
						}
					});
				}
				// Create lava spray damage zones - much more reduced frequency and damage
				if (self.lavaSprayTimer > 720) {
					self.lavaSprayTimer = 0;
					var sprayRadius = 100;
					var heroDx = hero.x - self.x;
					var heroDy = hero.y - self.y;
					var heroDistance = Math.sqrt(heroDx * heroDx + heroDy * heroDy);
					if (heroDistance <= sprayRadius) {
						hero.takeDamage(5);
						LK.effects.flashObject(hero, 0xff4500, 100);
					}
				}
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			} else if (self.type.indexOf('omega') === 0) {
				// Omega animals have enhanced movement
				self.omegaTimer++;
				if (self.omegaTimer > 60) {
					self.omegaTimer = 0;
					// Omega boost
					tween(enemyGraphics, {
						tint: 0xff00ff
					}, {
						duration: 200,
						onFinish: function onFinish() {
							tween(enemyGraphics, {
								tint: 0xffffff
							}, {
								duration: 200
							});
						}
					});
					self.x += dx / distance * self.speed * 3;
					self.y += dy / distance * self.speed * 3;
				} else {
					self.x += dx / distance * self.speed;
					self.y += dy / distance * self.speed;
				}
			} else {
				// Normal movement for other enemies
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
	};
	return self;
});
var Erdo = Container.expand(function () {
	var self = Container.call(this);
	var erdoGraphics = self.attachAsset('erdo', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.lastShot = 0;
	self.shootCooldown = 80; // Very fast shooting
	self.isActive = false;
	self.activationTimer = 0;
	self.maxActivationTime = 15000; // 15 seconds active
	self.isMovingToCenter = false;
	self.targetX = 0;
	self.targetY = 0;
	self.shootDirections = [{
		x: 1,
		y: 0
	}, {
		x: -1,
		y: 0
	}, {
		x: 0,
		y: 1
	}, {
		x: 0,
		y: -1
	}, {
		x: 0.707,
		y: 0.707
	}, {
		x: -0.707,
		y: 0.707
	}, {
		x: 0.707,
		y: -0.707
	}, {
		x: -0.707,
		y: -0.707
	}];
	self.activate = function () {
		self.isActive = true;
		self.activationTimer = 0;
		self.visible = true;
		self.alpha = 0;
		self.isMovingToCenter = true;
		// Spawn from random edge
		var side = Math.floor(Math.random() * 4);
		if (side === 0) {
			// Top
			self.x = Math.random() * 2048;
			self.y = -50;
		} else if (side === 1) {
			// Right
			self.x = 2048 + 50;
			self.y = Math.random() * 2732;
		} else if (side === 2) {
			// Bottom
			self.x = Math.random() * 2048;
			self.y = 2732 + 50;
		} else {
			// Left
			self.x = -50;
			self.y = Math.random() * 2732;
		}
		// Set target to center
		self.targetX = 2048 / 2;
		self.targetY = 2732 / 2;
		// Fade in effect
		tween(self, {
			alpha: 1
		}, {
			duration: 300
		});
		LK.getSound('powerUp').play();
	};
	self.deactivate = function () {
		self.isActive = false;
		self.isMovingToCenter = false;
		// Grant hero enhanced abilities for 15 seconds after Erdo leaves
		hero.hasShield = true;
		hero.shieldDuration = 15000; // 15 seconds shield
		hero.explosiveShotMode = true;
		hero.explosiveShotDuration = 15000; // 15 seconds explosive shots
		hero.rapidShootCooldown = 200; // 0.2 seconds between shots
		hero.shootCooldown = hero.rapidShootCooldown;
		// Visual effect for enhanced mode
		tween(hero, {
			tint: 0xffaa00
		}, {
			duration: 500
		});
		// Fade out effect
		tween(self, {
			alpha: 0
		}, {
			duration: 300,
			onFinish: function onFinish() {
				self.visible = false;
			}
		});
	};
	self.shootInAllDirections = function () {
		// Only shoot if there are enemies to target
		if (enemies.length === 0) return;
		for (var i = 0; i < enemies.length && i < self.shootDirections.length; i++) {
			var enemy = enemies[i];
			var bullet = new Bullet();
			bullet.x = self.x;
			bullet.y = self.y;
			bullet.setTarget(enemy.x, enemy.y);
			bullet.speed = 15; // Very fast bullets
			bullets.push(bullet);
			game.addChild(bullet);
		}
		LK.getSound('shoot').play();
	};
	self.update = function () {
		if (!self.isActive) return;
		self.activationTimer += 16.67;
		// Move to center first
		if (self.isMovingToCenter) {
			var dx = self.targetX - self.x;
			var dy = self.targetY - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > 20) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			} else {
				self.isMovingToCenter = false;
			}
		}
		// Shoot rapidly in all directions when in center
		if (!self.isMovingToCenter && LK.ticks - self.lastShot > self.shootCooldown / 16.67) {
			self.shootInAllDirections();
			self.lastShot = LK.ticks;
		}
		// Deactivate after time limit
		if (self.activationTimer >= self.maxActivationTime) {
			self.deactivate();
		}
	};
	self.visible = false;
	return self;
});
var EvilErdo = Container.expand(function () {
	var self = Container.call(this);
	var evilErdoGraphics = self.attachAsset('erdo', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2.5,
		scaleY: 2.5
	});
	evilErdoGraphics.tint = 0xff0000; // Red tint for evil
	self.health = 500;
	self.maxHealth = 500;
	self.speed = 3;
	self.damage = 40;
	self.lastShot = 0;
	self.shootCooldown = 120; // 2 seconds between shots
	self.isBoss = true;
	self.phase = 1; // Boss has 3 phases
	self.phaseTimer = 0;
	self.isActive = false;
	self.teleportTimer = 0;
	self.darkEnergyTimer = 0;
	self.shootDirections = [{
		x: 1,
		y: 0
	}, {
		x: -1,
		y: 0
	}, {
		x: 0,
		y: 1
	}, {
		x: 0,
		y: -1
	}, {
		x: 0.707,
		y: 0.707
	}, {
		x: -0.707,
		y: 0.707
	}, {
		x: 0.707,
		y: -0.707
	}, {
		x: -0.707,
		y: -0.707
	}];
	self.activate = function () {
		self.isActive = true;
		self.visible = true;
		self.alpha = 0;
		self.health = self.maxHealth;
		self.phase = 1;
		self.phaseTimer = 0;
		// Spawn at center of screen
		self.x = 2048 / 2;
		self.y = 2732 / 2;
		// Dark entrance effect
		LK.effects.flashScreen(0x800080, 1000);
		tween(self, {
			alpha: 1
		}, {
			duration: 500
		});
		// Stop all enemy spawning
		evilErdoBattleActive = true;
		// Clear all existing enemies
		for (var i = enemies.length - 1; i >= 0; i--) {
			enemies[i].destroy();
			enemies.splice(i, 1);
		}
		LK.getSound('powerUp').play();
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		// Create dark energy effect when hit
		createBloodSplatter(self.x, self.y, Math.min(damage / 6, 20));
		// Flash red when hit
		tween(evilErdoGraphics, {
			tint: 0xffffff
		}, {
			duration: 100
		});
		tween(evilErdoGraphics, {
			tint: 0xff0000
		}, {
			duration: 100
		});
		// Check for phase transitions
		if (self.health <= self.maxHealth * 0.66 && self.phase === 1) {
			self.phase = 2;
			self.phaseTimer = 0;
			self.shootCooldown = 80; // Faster shooting
			LK.effects.flashScreen(0x4B0082, 500);
		} else if (self.health <= self.maxHealth * 0.33 && self.phase === 2) {
			self.phase = 3;
			self.phaseTimer = 0;
			self.shootCooldown = 60; // Even faster shooting
			self.speed = 4;
			LK.effects.flashScreen(0x000000, 800);
		}
		if (self.health <= 0) {
			// Create massive explosion when defeated
			createBloodSplatter(self.x, self.y, 30);
			LK.effects.flashScreen(0xFFD700, 1000);
			// End evil erdo battle
			evilErdoBattleActive = false;
			return true;
		}
		return false;
	};
	self.shootAtHero = function () {
		var bullet = new Bullet();
		bullet.x = self.x;
		bullet.y = self.y;
		bullet.setTarget(hero.x, hero.y);
		bullet.damage = self.damage;
		bullet.speed = 8;
		// Make bullet red for evil erdo
		if (bullet.attachAsset) {
			var bulletGraphics = bullet.attachAsset('bullet', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			bulletGraphics.tint = 0xff0000;
		}
		bullets.push(bullet);
		game.addChild(bullet);
	};
	self.shootInAllDirections = function () {
		for (var i = 0; i < self.shootDirections.length; i++) {
			var direction = self.shootDirections[i];
			var bullet = new Bullet();
			bullet.x = self.x;
			bullet.y = self.y;
			var targetX = self.x + direction.x * 500;
			var targetY = self.y + direction.y * 500;
			bullet.setTarget(targetX, targetY);
			bullet.damage = self.damage;
			bullet.speed = 10;
			bullets.push(bullet);
			game.addChild(bullet);
		}
	};
	self.darkEnergyAttack = function () {
		// Create dark energy explosion around evil erdo
		var explosionRadius = 200;
		var heroDx = hero.x - self.x;
		var heroDy = hero.y - self.y;
		var heroDistance = Math.sqrt(heroDx * heroDx + heroDy * heroDy);
		if (heroDistance <= explosionRadius) {
			hero.takeDamage(25);
			LK.effects.flashObject(hero, 0x800080, 300);
		}
		createBloodSplatter(self.x, self.y, 25);
		LK.effects.flashScreen(0x4B0082, 200);
	};
	self.update = function () {
		if (!self.isActive) return;
		self.phaseTimer += 16.67;
		self.teleportTimer += 16.67;
		self.darkEnergyTimer += 16.67;
		// Move towards hero
		var dx = hero.x - self.x;
		var dy = hero.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;
		}
		// Phase 1: Basic shooting
		if (self.phase === 1) {
			if (LK.ticks - self.lastShot > self.shootCooldown / 16.67) {
				self.shootAtHero();
				self.lastShot = LK.ticks;
			}
		}
		// Phase 2: Multi-directional shooting + teleport
		else if (self.phase === 2) {
			if (LK.ticks - self.lastShot > self.shootCooldown / 16.67) {
				self.shootInAllDirections();
				self.lastShot = LK.ticks;
			}
			// Teleport occasionally
			if (self.teleportTimer > 3000) {
				self.teleportTimer = 0;
				var newX = Math.random() * (2048 - 200) + 100;
				var newY = Math.random() * (2732 - 200) + 100;
				tween(self, {
					x: newX,
					y: newY
				}, {
					duration: 300
				});
				LK.effects.flashScreen(0x9400D3, 200);
			}
		}
		// Phase 3: All attacks + dark energy
		else if (self.phase === 3) {
			if (LK.ticks - self.lastShot > self.shootCooldown / 16.67) {
				self.shootInAllDirections();
				self.shootAtHero();
				self.lastShot = LK.ticks;
			}
			// More frequent teleporting
			if (self.teleportTimer > 2000) {
				self.teleportTimer = 0;
				var newX = Math.random() * (2048 - 200) + 100;
				var newY = Math.random() * (2732 - 200) + 100;
				tween(self, {
					x: newX,
					y: newY
				}, {
					duration: 200
				});
				LK.effects.flashScreen(0x000000, 300);
			}
			// Dark energy attacks
			if (self.darkEnergyTimer > 1500) {
				self.darkEnergyTimer = 0;
				self.darkEnergyAttack();
			}
		}
	};
	self.visible = false;
	return self;
});
var ExplosiveBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bulletGraphics.tint = 0xff4400; // Orange tint for explosive bullets
	bulletGraphics.scaleX = 1.3;
	bulletGraphics.scaleY = 1.3;
	self.speed = 12;
	self.damage = 40; // Reduced damage
	self.targetX = 0;
	self.targetY = 0;
	self.directionX = 0;
	self.directionY = 0;
	self.setTarget = function (x, y) {
		self.targetX = x;
		self.targetY = y;
		var dx = x - self.x;
		var dy = y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.directionX = dx / distance;
			self.directionY = dy / distance;
		}
	};
	self.explode = function () {
		// Create explosion visual effect
		LK.effects.flashObject(self, 0xff4400, 300);
		createBloodSplatter(self.x, self.y, 15);
		// Damage enemies in explosion radius
		var explosionRadius = 60;
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= explosionRadius) {
				var enemyDied = enemy.takeDamage(self.damage * 0.7);
				if (enemyDied) {
					LK.setScore(LK.getScore() + 10);
					scoreTxt.setText('Score: ' + LK.getScore());
					enemy.destroy();
					enemies.splice(i, 1);
				}
			}
		}
	};
	self.update = function () {
		self.x += self.directionX * self.speed;
		self.y += self.directionY * self.speed;
	};
	return self;
});
var Hero = Container.expand(function () {
	var self = Container.call(this);
	var heroGraphics = self.attachAsset('hero', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.maxHealth = 100;
	self.health = self.maxHealth;
	self.speed = 2.5;
	self.normalSpeed = 3;
	self.boostedSpeed = 6;
	self.hasShield = false;
	self.shieldDuration = 0;
	self.rapidFire = false;
	self.rapidFireDuration = 0;
	self.lastShot = 0;
	self.shootCooldown = 500; // milliseconds
	self.normalShootCooldown = 500;
	self.rapidShootCooldown = 150;
	self.hyperchargeMode = false;
	self.hyperhargeDuration = 0;
	self.invisibilityMode = false;
	self.invisibilityDuration = 0;
	self.multiShotMode = false;
	self.multiShotDuration = 0;
	self.timeSlowMode = false;
	self.timeSlowDuration = 0;
	self.timeStopMode = false;
	self.timeStopDuration = 0;
	self.timeRewindMode = false;
	self.timeRewindDuration = 0;
	self.explosiveShotMode = false;
	self.explosiveShotDuration = 0;
	self.lifeStealMode = false;
	self.lifeStealDuration = 0;
	self.berserkerMode = false;
	self.berserkerDuration = 0;
	self.magnetMode = false;
	self.magnetDuration = 0;
	self.reflectMode = false;
	self.reflectDuration = 0;
	self.phoenixMode = false;
	self.phoenixDuration = 0;
	self.vampireMode = false;
	self.vampireDuration = 0;
	self.godMode = false;
	self.godModeDuration = 0;
	self.shadowStrikeMode = false;
	self.shadowStrikeDuration = 0;
	self.necromancyMode = false;
	self.necromancyDuration = 0;
	self.auraMode = false;
	self.auraDuration = 0;
	self.chainLightningMode = false;
	self.chainLightningDuration = 0;
	self.summonMode = false;
	self.summonDuration = 0;
	self.meteorMode = false;
	self.meteorDuration = 0;
	self.berserkAuraMode = false;
	self.berserkAuraDuration = 0;
	self.dimensionRiftMode = false;
	self.dimensionRiftDuration = 0;
	self.divineBlastMode = false;
	self.divineBlastDuration = 0;
	self.apocalypseMode = false;
	self.apocalypseDuration = 0;
	self.titanShieldMode = false;
	self.titanShieldDuration = 0;
	self.berserkRageMode = false;
	self.berserkRageDuration = 0;
	self.lightningStormMode = false;
	self.lightningStormDuration = 0;
	self.bloodRainMode = false;
	self.bloodRainDuration = 0;
	self.voidWalkerMode = false;
	self.voidWalkerDuration = 0;
	self.cosmicRageMode = false;
	self.cosmicRageDuration = 0;
	self.soulHarvestMode = false;
	self.soulHarvestDuration = 0;
	self.timeDistortionMode = false;
	self.timeDistortionDuration = 0;
	self.elementalFuryMode = false;
	self.elementalFuryDuration = 0;
	self.quantumLeapMode = false;
	self.quantumLeapDuration = 0;
	self.dragonBreathMode = false;
	self.dragonBreathDuration = 0;
	self.arcaneStormMode = false;
	self.arcaneStormDuration = 0;
	self.plasmaBurstMode = false;
	self.plasmaBurstDuration = 0;
	self.galaxyCollapseMode = false;
	self.galaxyCollapseDuration = 0;
	self.infinityMode = false;
	self.infinityDuration = 0;
	self.omegaDestructionMode = false;
	self.omegaDestructionDuration = 0;
	self.savedPosition = {
		x: 0,
		y: 0
	};
	self.savedHealth = 0;
	var shieldGraphics = self.attachAsset('shieldEffect', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.5
	});
	shieldGraphics.visible = false;
	self.takeDamage = function (damage) {
		if (self.hasShield) {
			return false; // No damage taken
		}
		self.health -= damage;
		// Create blood splatter effect when hero is hit
		createBloodSplatter(self.x, self.y, Math.min(damage / 8, 10));
		// Create blood trail when hero is damaged
		createBloodTrail(self.x, self.y);
		if (self.health <= 0) {
			self.health = 0;
			// Create large blood splatter when hero dies
			createBloodSplatter(self.x, self.y, 15);
			return true; // Hero died
		}
		return false;
	};
	self.activateShield = function () {
		self.hasShield = true;
		self.shieldDuration = 5000; // 5 seconds
		shieldGraphics.visible = true;
		LK.getSound('powerUp').play();
	};
	self.activateSpeedBoost = function () {
		self.speed = self.boostedSpeed;
		LK.getSound('powerUp').play();
		LK.setTimeout(function () {
			self.speed = self.normalSpeed;
		}, 3000);
	};
	self.activateRapidFire = function () {
		self.rapidFire = true;
		self.rapidFireDuration = 4000; // 4 seconds
		self.shootCooldown = self.rapidShootCooldown;
		LK.getSound('powerUp').play();
	};
	self.activateFreeze = function () {
		freezeEnemies();
		LK.getSound('powerUp').play();
	};
	self.activateExplosion = function () {
		explodeNearbyEnemies();
		LK.getSound('powerUp').play();
	};
	self.activateHealing = function () {
		self.health = Math.min(self.health + 30, self.maxHealth);
		LK.getSound('powerUp').play();
	};
	self.activateHypercharge = function () {
		self.hyperchargeMode = true;
		self.hyperhargeDuration = 8000; // 8 seconds
		self.speed = self.boostedSpeed * 1.5;
		self.shootCooldown = 50; // Very fast shooting
		heroGraphics.tint = 0xffff00; // Yellow tint
		LK.getSound('hypercharge').play();
	};
	self.activateTeleport = function () {
		// Teleport to random safe location
		var safeX = Math.random() * (2048 - 160) + 80;
		var safeY = Math.random() * (2732 - 160) + 80;
		tween(self, {
			x: safeX,
			y: safeY
		}, {
			duration: 100
		});
		LK.getSound('teleport').play();
	};
	self.activateInvisibility = function () {
		self.invisibilityMode = true;
		self.invisibilityDuration = 5000; // 5 seconds
		heroGraphics.alpha = 0.3;
		LK.getSound('powerUp').play();
	};
	self.activateMultiShot = function () {
		self.multiShotMode = true;
		self.multiShotDuration = 6000; // 6 seconds
		LK.getSound('powerUp').play();
	};
	self.activateTimeSlow = function () {
		self.timeSlowMode = true;
		self.timeSlowDuration = 8000; // 8 seconds
		timeSlowFactor = 0.3; // Slow down time
		LK.getSound('timeSlow').play();
	};
	self.activateTimeStop = function () {
		self.timeStopMode = true;
		self.timeStopDuration = 3000; // 3 seconds
		timeStopActive = true;
		LK.getSound('timeStop').play();
	};
	self.activateTimeRewind = function () {
		// Save current position and health for rewind
		self.savedPosition.x = self.x;
		self.savedPosition.y = self.y;
		self.savedHealth = self.health;
		self.timeRewindMode = true;
		self.timeRewindDuration = 5000; // 5 seconds
		LK.getSound('timeRewind').play();
	};
	self.activateLifeSteal = function () {
		self.lifeStealMode = true;
		self.lifeStealDuration = 10000; // 10 seconds
		heroGraphics.tint = 0x8B0000; // Dark red tint
		LK.getSound('powerUp').play();
	};
	self.activateBerserker = function () {
		self.berserkerMode = true;
		self.berserkerDuration = 8000; // 8 seconds
		self.speed = self.normalSpeed * 2;
		self.shootCooldown = 50; // Very fast shooting
		heroGraphics.tint = 0xFF4500; // Orange red tint
		LK.getSound('powerUp').play();
	};
	self.activateMagnet = function () {
		self.magnetMode = true;
		self.magnetDuration = 12000; // 12 seconds
		heroGraphics.tint = 0x4169E1; // Blue tint
		LK.getSound('powerUp').play();
	};
	self.activateReflect = function () {
		self.reflectMode = true;
		self.reflectDuration = 6000; // 6 seconds
		heroGraphics.tint = 0x9932CC; // Purple tint
		LK.getSound('powerUp').play();
	};
	self.activatePhoenix = function () {
		self.phoenixMode = true;
		self.phoenixDuration = 15000; // 15 seconds - one time revival
		heroGraphics.tint = 0xFF6347; // Tomato red tint
		LK.getSound('powerUp').play();
	};
	self.activateVampire = function () {
		self.vampireMode = true;
		self.vampireDuration = 10000; // 10 seconds
		heroGraphics.tint = 0x800080; // Purple tint
		LK.getSound('powerUp').play();
	};
	self.activateGodMode = function () {
		self.godMode = true;
		self.godModeDuration = 2000; // 2 seconds
		heroGraphics.tint = 0xFFD700; // Gold tint
		self.hasShield = true;
		self.speed = self.normalSpeed * 1.5;
		self.shootCooldown = 150; // Fast shooting but not ultra fast
		LK.getSound('powerUp').play();
	};
	self.activateShadowStrike = function () {
		self.shadowStrikeMode = true;
		self.shadowStrikeDuration = 8000; // 8 seconds
		heroGraphics.tint = 0x2f1b69; // Dark purple tint
		self.speed = self.normalSpeed * 2.5;
		self.shootCooldown = 100; // Fast shooting
		LK.getSound('powerUp').play();
	};
	self.activateNecromancy = function () {
		self.necromancyMode = true;
		self.necromancyDuration = 12000; // 12 seconds
		heroGraphics.tint = 0x1a0d1a; // Dark black tint
		LK.getSound('powerUp').play();
	};
	self.activateAura = function () {
		self.auraMode = true;
		self.auraDuration = 10000; // 10 seconds
		heroGraphics.tint = 0xffd43b; // Bright yellow tint
		self.speed = self.normalSpeed * 1.8;
		LK.getSound('powerUp').play();
	};
	self.activateChainLightning = function () {
		self.chainLightningMode = true;
		self.chainLightningDuration = 6000; // 6 seconds
		heroGraphics.tint = 0x4a90e2; // Electric blue tint
		LK.getSound('powerUp').play();
	};
	self.activateSummon = function () {
		self.summonMode = true;
		self.summonDuration = 15000; // 15 seconds
		heroGraphics.tint = 0x7ed321; // Green tint
		LK.getSound('powerUp').play();
	};
	self.activateMeteor = function () {
		self.meteorMode = true;
		self.meteorDuration = 8000; // 8 seconds
		heroGraphics.tint = 0xd0021b; // Red tint
		LK.getSound('powerUp').play();
	};
	self.activateBerserkAura = function () {
		self.berserkAuraMode = true;
		self.berserkAuraDuration = 10000; // 10 seconds
		heroGraphics.tint = 0xf5a623; // Orange tint
		self.speed = self.normalSpeed * 2.2;
		self.shootCooldown = 60; // Very fast shooting
		LK.getSound('powerUp').play();
	};
	self.activateDimensionRift = function () {
		self.dimensionRiftMode = true;
		self.dimensionRiftDuration = 7000; // 7 seconds
		heroGraphics.tint = 0x9013fe; // Purple tint
		LK.getSound('powerUp').play();
	};
	self.activateDivineBlast = function () {
		self.divineBlastMode = true;
		self.divineBlastDuration = 5000; // 5 seconds
		heroGraphics.tint = 0xffffff; // White tint
		self.shootCooldown = 50; // Fast shooting
		LK.getSound('powerUp').play();
	};
	self.activateApocalypse = function () {
		self.apocalypseMode = true;
		self.apocalypseDuration = 6000; // 6 seconds
		heroGraphics.tint = 0x000000; // Black tint
		self.speed = self.normalSpeed * 1.5;
		self.shootCooldown = 40; // Very fast shooting
		LK.getSound('powerUp').play();
	};
	self.activateTitanShield = function () {
		self.titanShieldMode = true;
		self.titanShieldDuration = 12000; // 12 seconds
		self.hasShield = true;
		self.damage *= 2; // Double damage while shielded
		heroGraphics.tint = 0x4169e1; // Blue steel tint
		LK.getSound('powerUp').play();
	};
	self.activateBerserkRage = function () {
		self.berserkRageMode = true;
		self.berserkRageDuration = 8000; // 8 seconds
		self.speed = self.normalSpeed * 3;
		self.shootCooldown = 30; // Ultra fast shooting
		self.damage *= 3; // Triple damage
		heroGraphics.tint = 0x8b0000; // Dark red tint
		LK.getSound('powerUp').play();
	};
	self.activateLightningStorm = function () {
		self.lightningStormMode = true;
		self.lightningStormDuration = 10000; // 10 seconds
		heroGraphics.tint = 0xffff00; // Yellow tint
		LK.getSound('powerUp').play();
	};
	self.activateBloodRain = function () {
		self.bloodRainMode = true;
		self.bloodRainDuration = 15000; // 15 seconds
		heroGraphics.tint = 0x8b0000; // Blood red tint
		LK.getSound('powerUp').play();
	};
	self.activateVoidWalker = function () {
		self.voidWalkerMode = true;
		self.voidWalkerDuration = 20000; // 20 seconds
		heroGraphics.tint = 0x1a0033; // Deep void purple
		self.hasShield = true;
		self.speed = self.normalSpeed * 4;
		self.shootCooldown = 20; // Ultra fast shooting
		LK.getSound('powerUp').play();
	};
	self.activateCosmicRage = function () {
		self.cosmicRageMode = true;
		self.cosmicRageDuration = 18000; // 18 seconds
		heroGraphics.tint = 0xff0099; // Cosmic pink
		self.damage *= 5; // Quintuple damage
		self.speed = self.normalSpeed * 3.5;
		LK.getSound('powerUp').play();
	};
	self.activateSoulHarvest = function () {
		self.soulHarvestMode = true;
		self.soulHarvestDuration = 25000; // 25 seconds
		heroGraphics.tint = 0x660066; // Soul purple
		LK.getSound('powerUp').play();
	};
	self.activateTimeDistortion = function () {
		self.timeDistortionMode = true;
		self.timeDistortionDuration = 15000; // 15 seconds
		heroGraphics.tint = 0x00ccff; // Time blue
		timeSlowFactor = 0.1; // Extremely slow time
		LK.getSound('powerUp').play();
	};
	self.activateElementalFury = function () {
		self.elementalFuryMode = true;
		self.elementalFuryDuration = 22000; // 22 seconds
		heroGraphics.tint = 0xff6600; // Elemental orange
		self.shootCooldown = 15; // Super fast shooting
		LK.getSound('powerUp').play();
	};
	self.activateQuantumLeap = function () {
		self.quantumLeapMode = true;
		self.quantumLeapDuration = 20000; // 20 seconds
		heroGraphics.tint = 0x00ff99; // Quantum green
		self.speed = self.normalSpeed * 6;
		LK.getSound('powerUp').play();
	};
	self.activateDragonBreath = function () {
		self.dragonBreathMode = true;
		self.dragonBreathDuration = 16000; // 16 seconds
		heroGraphics.tint = 0xff3300; // Dragon red
		LK.getSound('powerUp').play();
	};
	self.activateArcaneStorm = function () {
		self.arcaneStormMode = true;
		self.arcaneStormDuration = 24000; // 24 seconds
		heroGraphics.tint = 0x9933ff; // Arcane purple
		LK.getSound('powerUp').play();
	};
	self.activatePlasmaBurst = function () {
		self.plasmaBurstMode = true;
		self.plasmaBurstDuration = 14000; // 14 seconds
		heroGraphics.tint = 0x00ffff; // Plasma cyan
		self.shootCooldown = 10; // Extremely fast shooting
		LK.getSound('powerUp').play();
	};
	self.activateGalaxyCollapse = function () {
		self.galaxyCollapseMode = true;
		self.galaxyCollapseDuration = 12000; // 12 seconds
		heroGraphics.tint = 0x000066; // Galaxy dark blue
		LK.getSound('powerUp').play();
	};
	self.activateInfinity = function () {
		self.infinityMode = true;
		self.infinityDuration = 10000; // 10 seconds
		heroGraphics.tint = 0xffffff; // Infinity white
		self.hasShield = true;
		self.speed = self.normalSpeed * 3;
		self.shootCooldown = 100; // Fast shooting
		self.damage *= 2; // 2x damage
		LK.getSound('powerUp').play();
	};
	self.activateOmegaDestruction = function () {
		self.omegaDestructionMode = true;
		self.omegaDestructionDuration = 8000; // 8 seconds
		heroGraphics.tint = 0xff0000; // Omega red
		LK.getSound('powerUp').play();
	};
	self.update = function () {
		if (self.shieldDuration > 0) {
			self.shieldDuration -= 16.67; // Approximately 60fps
			if (self.shieldDuration <= 0) {
				self.hasShield = false;
				shieldGraphics.visible = false;
			}
		}
		if (self.rapidFireDuration > 0) {
			self.rapidFireDuration -= 16.67;
			if (self.rapidFireDuration <= 0) {
				self.rapidFire = false;
				self.shootCooldown = self.normalShootCooldown;
			}
		}
		if (self.hyperhargeDuration > 0) {
			self.hyperhargeDuration -= 16.67;
			if (self.hyperhargeDuration <= 0) {
				self.hyperchargeMode = false;
				self.speed = self.normalSpeed;
				self.shootCooldown = self.normalShootCooldown;
				heroGraphics.tint = 0xffffff;
			}
		}
		if (self.invisibilityDuration > 0) {
			self.invisibilityDuration -= 16.67;
			if (self.invisibilityDuration <= 0) {
				self.invisibilityMode = false;
				heroGraphics.alpha = 1.0;
			}
		}
		if (self.multiShotDuration > 0) {
			self.multiShotDuration -= 16.67;
			if (self.multiShotDuration <= 0) {
				self.multiShotMode = false;
			}
		}
		if (self.timeSlowDuration > 0) {
			self.timeSlowDuration -= 16.67;
			if (self.timeSlowDuration <= 0) {
				self.timeSlowMode = false;
				timeSlowFactor = 1.0; // Reset time speed
			}
		}
		if (self.timeStopDuration > 0) {
			self.timeStopDuration -= 16.67;
			if (self.timeStopDuration <= 0) {
				self.timeStopMode = false;
				timeStopActive = false;
			}
		}
		if (self.timeRewindDuration > 0) {
			self.timeRewindDuration -= 16.67;
			if (self.timeRewindDuration <= 0) {
				self.timeRewindMode = false;
				// Execute rewind effect
				self.x = self.savedPosition.x;
				self.y = self.savedPosition.y;
				self.health = self.savedHealth;
				tween(self, {
					alpha: 0.5
				}, {
					duration: 300,
					onFinish: function onFinish() {
						tween(self, {
							alpha: 1.0
						}, {
							duration: 300
						});
					}
				});
			}
		}
		if (self.explosiveShotDuration > 0) {
			self.explosiveShotDuration -= 16.67;
			if (self.explosiveShotDuration <= 0) {
				self.explosiveShotMode = false;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.lifeStealDuration > 0) {
			self.lifeStealDuration -= 16.67;
			if (self.lifeStealDuration <= 0) {
				self.lifeStealMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.berserkerDuration > 0) {
			self.berserkerDuration -= 16.67;
			if (self.berserkerDuration <= 0) {
				self.berserkerMode = false;
				self.speed = self.normalSpeed;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.magnetDuration > 0) {
			self.magnetDuration -= 16.67;
			if (self.magnetDuration <= 0) {
				self.magnetMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.reflectDuration > 0) {
			self.reflectDuration -= 16.67;
			if (self.reflectDuration <= 0) {
				self.reflectMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.phoenixDuration > 0) {
			self.phoenixDuration -= 16.67;
			if (self.phoenixDuration <= 0) {
				self.phoenixMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.vampireDuration > 0) {
			self.vampireDuration -= 16.67;
			if (self.vampireDuration <= 0) {
				self.vampireMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.godModeDuration > 0) {
			self.godModeDuration -= 16.67;
			if (self.godModeDuration <= 0) {
				self.godMode = false;
				self.hasShield = false;
				self.speed = self.normalSpeed;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.shadowStrikeDuration > 0) {
			self.shadowStrikeDuration -= 16.67;
			if (self.shadowStrikeDuration <= 0) {
				self.shadowStrikeMode = false;
				self.speed = self.normalSpeed;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.necromancyDuration > 0) {
			self.necromancyDuration -= 16.67;
			if (self.necromancyDuration <= 0) {
				self.necromancyMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.auraDuration > 0) {
			self.auraDuration -= 16.67;
			if (self.auraDuration <= 0) {
				self.auraMode = false;
				self.speed = self.normalSpeed;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.chainLightningDuration > 0) {
			self.chainLightningDuration -= 16.67;
			if (self.chainLightningDuration <= 0) {
				self.chainLightningMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.summonDuration > 0) {
			self.summonDuration -= 16.67;
			if (self.summonDuration <= 0) {
				self.summonMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.meteorDuration > 0) {
			self.meteorDuration -= 16.67;
			if (self.meteorDuration <= 0) {
				self.meteorMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.berserkAuraDuration > 0) {
			self.berserkAuraDuration -= 16.67;
			if (self.berserkAuraDuration <= 0) {
				self.berserkAuraMode = false;
				self.speed = self.normalSpeed;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.dimensionRiftDuration > 0) {
			self.dimensionRiftDuration -= 16.67;
			if (self.dimensionRiftDuration <= 0) {
				self.dimensionRiftMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.divineBlastDuration > 0) {
			self.divineBlastDuration -= 16.67;
			if (self.divineBlastDuration <= 0) {
				self.divineBlastMode = false;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.apocalypseDuration > 0) {
			self.apocalypseDuration -= 16.67;
			if (self.apocalypseDuration <= 0) {
				self.apocalypseMode = false;
				self.speed = self.normalSpeed;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.titanShieldDuration > 0) {
			self.titanShieldDuration -= 16.67;
			if (self.titanShieldDuration <= 0) {
				self.titanShieldMode = false;
				self.hasShield = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.berserkRageDuration > 0) {
			self.berserkRageDuration -= 16.67;
			if (self.berserkRageDuration <= 0) {
				self.berserkRageMode = false;
				self.speed = self.normalSpeed;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.lightningStormDuration > 0) {
			self.lightningStormDuration -= 16.67;
			if (self.lightningStormDuration <= 0) {
				self.lightningStormMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.bloodRainDuration > 0) {
			self.bloodRainDuration -= 16.67;
			if (self.bloodRainDuration <= 0) {
				self.bloodRainMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.voidWalkerDuration > 0) {
			self.voidWalkerDuration -= 16.67;
			if (self.voidWalkerDuration <= 0) {
				self.voidWalkerMode = false;
				self.hasShield = false;
				self.speed = self.normalSpeed;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.cosmicRageDuration > 0) {
			self.cosmicRageDuration -= 16.67;
			if (self.cosmicRageDuration <= 0) {
				self.cosmicRageMode = false;
				self.speed = self.normalSpeed;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.soulHarvestDuration > 0) {
			self.soulHarvestDuration -= 16.67;
			if (self.soulHarvestDuration <= 0) {
				self.soulHarvestMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.timeDistortionDuration > 0) {
			self.timeDistortionDuration -= 16.67;
			if (self.timeDistortionDuration <= 0) {
				self.timeDistortionMode = false;
				timeSlowFactor = 1.0;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.elementalFuryDuration > 0) {
			self.elementalFuryDuration -= 16.67;
			if (self.elementalFuryDuration <= 0) {
				self.elementalFuryMode = false;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.quantumLeapDuration > 0) {
			self.quantumLeapDuration -= 16.67;
			if (self.quantumLeapDuration <= 0) {
				self.quantumLeapMode = false;
				self.speed = self.normalSpeed;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.dragonBreathDuration > 0) {
			self.dragonBreathDuration -= 16.67;
			if (self.dragonBreathDuration <= 0) {
				self.dragonBreathMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.arcaneStormDuration > 0) {
			self.arcaneStormDuration -= 16.67;
			if (self.arcaneStormDuration <= 0) {
				self.arcaneStormMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.plasmaBurstDuration > 0) {
			self.plasmaBurstDuration -= 16.67;
			if (self.plasmaBurstDuration <= 0) {
				self.plasmaBurstMode = false;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.galaxyCollapseDuration > 0) {
			self.galaxyCollapseDuration -= 16.67;
			if (self.galaxyCollapseDuration <= 0) {
				self.galaxyCollapseMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.infinityDuration > 0) {
			self.infinityDuration -= 16.67;
			if (self.infinityDuration <= 0) {
				self.infinityMode = false;
				self.hasShield = false;
				self.speed = self.normalSpeed;
				self.shootCooldown = self.normalShootCooldown;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
		if (self.omegaDestructionDuration > 0) {
			self.omegaDestructionDuration -= 16.67;
			if (self.omegaDestructionDuration <= 0) {
				self.omegaDestructionMode = false;
				tween(heroGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		}
	};
	return self;
});
var HeroBase = Container.expand(function () {
	var self = Container.call(this);
	var baseGraphics = self.attachAsset('heroBase', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.turrets = [];
	self.initializeTurrets = function () {
		// Create 4 turrets around the base
		var turretPositions = [{
			x: -60,
			y: -60
		}, {
			x: 60,
			y: -60
		}, {
			x: -60,
			y: 60
		}, {
			x: 60,
			y: 60
		}];
		for (var i = 0; i < turretPositions.length; i++) {
			var turret = new BaseTurret();
			turret.x = self.x + turretPositions[i].x;
			turret.y = self.y + turretPositions[i].y;
			self.turrets.push(turret);
			game.addChild(turret);
		}
	};
	self.isHeroInSafeZone = function (heroX, heroY) {
		var dx = heroX - self.x;
		var dy = heroY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		return distance <= 120;
	};
	self.update = function () {
		// Update turret positions relative to base
		for (var i = 0; i < self.turrets.length; i++) {
			var turret = self.turrets[i];
			turret.update();
		}
	};
	return self;
});
var Lion = Container.expand(function () {
	var self = Container.call(this);
	var lionGraphics = self.attachAsset('lion', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 2.0;
	self.damage = 45;
	self.health = 120;
	self.maxHealth = 120;
	self.roarTimer = 0;
	self.takeDamage = function (damage) {
		self.health -= damage;
		tween(lionGraphics, {
			tint: 0xff0000
		}, {
			duration: 100
		});
		tween(lionGraphics, {
			tint: 0xffffff
		}, {
			duration: 100
		});
		if (self.health <= 0) {
			return true;
		}
		return false;
	};
	self.update = function () {
		var dx = hero.x - self.x;
		var dy = hero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.roarTimer++;
			if (self.roarTimer > 90) {
				self.roarTimer = 0;
				// Roar effect - speeds up briefly
				self.x += dx / distance * self.speed * 3;
				self.y += dy / distance * self.speed * 3;
			} else {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
	};
	return self;
});
var MiracleMenu = Container.expand(function () {
	var self = Container.call(this);
	var menuBg = LK.getAsset('baseMenu', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x2c2c2c,
		width: 2048,
		height: 2732
	});
	self.isVisible = false;
	self.visible = false;
	self.buttons = [];
	self.buttonTexts = [];
	self.miracleIcons = [];
	self.createMiracleButtons = function () {
		// Clear existing buttons
		for (var i = 0; i < self.buttons.length; i++) {
			if (self.buttons[i]) self.buttons[i].destroy();
		}
		for (var i = 0; i < self.buttonTexts.length; i++) {
			if (self.buttonTexts[i]) self.buttonTexts[i].destroy();
		}
		for (var i = 0; i < self.miracleIcons.length; i++) {
			if (self.miracleIcons[i]) self.miracleIcons[i].destroy();
		}
		self.buttons = [];
		self.buttonTexts = [];
		self.miracleIcons = [];
		// Add title
		var titleText = new Text2('STORED MIRACLES - CLICK TO USE', {
			size: 70,
			fill: 0xFFD700
		});
		titleText.anchor.set(0.5, 0.5);
		titleText.x = 0;
		titleText.y = -300;
		self.addChild(titleText);
		// Add miracle count
		var countText = new Text2('(' + storedMiracles.length + '/' + maxStoredMiracles + ')', {
			size: 50,
			fill: 0xFFFF00
		});
		countText.anchor.set(0.5, 0.5);
		countText.x = 0;
		countText.y = -250;
		self.addChild(countText);
		// Create buttons for each stored miracle
		var startY = -150;
		var buttonWidth = 600;
		var buttonHeight = 80;
		for (var i = 0; i < storedMiracles.length; i++) {
			var miracleType = storedMiracles[i];
			var button = LK.getAsset('menuButton', {
				anchorX: 0.5,
				anchorY: 0.5,
				tint: 0x4444ff,
				width: buttonWidth,
				height: buttonHeight
			});
			button.x = 0;
			button.y = startY + i * 100;
			button.miracleType = miracleType;
			button.miracleIndex = i;
			self.addChild(button);
			self.buttons.push(button);
			// Create miracle icon
			var miracleIcon = createMiracleIcon(miracleType);
			miracleIcon.x = -200;
			miracleIcon.y = startY + i * 100;
			self.addChild(miracleIcon);
			self.miracleIcons.push(miracleIcon);
			// Create button text
			var buttonText = new Text2(miracleType.toUpperCase(), {
				size: 40,
				fill: 0xffffff
			});
			buttonText.anchor.set(0.5, 0.5);
			buttonText.x = 0;
			buttonText.y = startY + i * 100;
			self.addChild(buttonText);
			self.buttonTexts.push(buttonText);
		}
		// Add activate all button
		var activateAllButton = LK.getAsset('menuButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			tint: 0xff6600,
			width: 450,
			height: 80
		});
		activateAllButton.x = 0;
		activateAllButton.y = startY + storedMiracles.length * 100 + 50;
		activateAllButton.actionType = 'activateAll';
		self.addChild(activateAllButton);
		self.buttons.push(activateAllButton);
		var activateAllText = new Text2('ACTIVATE ALL', {
			size: 40,
			fill: 0xffffff
		});
		activateAllText.anchor.set(0.5, 0.5);
		activateAllText.x = 0;
		activateAllText.y = startY + storedMiracles.length * 100 + 50;
		self.addChild(activateAllText);
		self.buttonTexts.push(activateAllText);
		// Add movement freedom button
		var movementButton = LK.getAsset('menuButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			tint: 0x00aa00,
			width: 400,
			height: 80
		});
		movementButton.x = 0;
		movementButton.y = startY + storedMiracles.length * 100 + 100;
		movementButton.actionType = 'freeMovement';
		self.addChild(movementButton);
		self.buttons.push(movementButton);
		var movementText = new Text2('FREE MOVEMENT', {
			size: 40,
			fill: 0xffffff
		});
		movementText.anchor.set(0.5, 0.5);
		movementText.x = 0;
		movementText.y = startY + storedMiracles.length * 100 + 100;
		self.addChild(movementText);
		self.buttonTexts.push(movementText);
		// Add close button
		var closeButton = LK.getAsset('menuButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			tint: 0xff4444,
			width: 200,
			height: 60
		});
		closeButton.x = 0;
		closeButton.y = startY + storedMiracles.length * 100 + 200;
		closeButton.actionType = 'close';
		self.addChild(closeButton);
		self.buttons.push(closeButton);
		var closeText = new Text2('CLOSE', {
			size: 30,
			fill: 0xffffff
		});
		closeText.anchor.set(0.5, 0.5);
		closeText.x = 0;
		closeText.y = startY + storedMiracles.length * 100 + 200;
		self.addChild(closeText);
		self.buttonTexts.push(closeText);
	};
	self.show = function () {
		self.isVisible = true;
		self.visible = true;
		self.alpha = 0;
		self.scaleX = 0.8;
		self.scaleY = 0.8;
		// Remove gamePaused = true to keep enemies spawning
		self.createMiracleButtons();
		tween(self, {
			alpha: 1,
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 300
		});
	};
	self.hide = function () {
		self.isVisible = false;
		// Remove gamePaused = false since game is not paused
		tween(self, {
			alpha: 0,
			scaleX: 0.8,
			scaleY: 0.8
		}, {
			duration: 300,
			onFinish: function onFinish() {
				self.visible = false;
			}
		});
	};
	self.down = function (x, y, obj) {
		if (!self.isVisible) return;
		// Convert screen coordinates to local menu coordinates
		var localX = x - self.x;
		var localY = y - self.y;
		for (var i = 0; i < self.buttons.length; i++) {
			var button = self.buttons[i];
			var dx = localX - button.x;
			var dy = localY - button.y;
			var buttonWidth = button.actionType === 'close' ? 100 : button.actionType === 'freeMovement' ? 200 : button.actionType === 'activateAll' ? 225 : 300;
			var buttonHeight = button.actionType === 'close' ? 30 : 40;
			if (Math.abs(dx) <= buttonWidth && Math.abs(dy) <= buttonHeight) {
				if (button.actionType === 'close') {
					self.hide();
				} else if (button.actionType === 'freeMovement') {
					self.hide();
					// Teleport hero away from base
					var teleportX = Math.random() * (2048 - 200) + 100;
					var teleportY = Math.random() * (2732 - 400) + 200;
					// Ensure not too close to base
					while (Math.sqrt((teleportX - heroBase.x) * (teleportX - heroBase.x) + (teleportY - heroBase.y) * (teleportY - heroBase.y)) < 300) {
						teleportX = Math.random() * (2048 - 200) + 100;
						teleportY = Math.random() * (2732 - 400) + 200;
					}
					hero.x = teleportX;
					hero.y = teleportY;
					LK.getSound('teleport').play();
				} else if (button.actionType === 'activateAll') {
					// Activate all stored miracles
					for (var j = storedMiracles.length - 1; j >= 0; j--) {
						useStoredMiracle(j);
					}
					self.hide();
					// Teleport hero away from base
					var teleportX = Math.random() * (2048 - 200) + 100;
					var teleportY = Math.random() * (2732 - 400) + 200;
					// Ensure not too close to base
					while (Math.sqrt((teleportX - heroBase.x) * (teleportX - heroBase.x) + (teleportY - heroBase.y) * (teleportY - heroBase.y)) < 300) {
						teleportX = Math.random() * (2048 - 200) + 100;
						teleportY = Math.random() * (2732 - 400) + 200;
					}
					hero.x = teleportX;
					hero.y = teleportY;
					LK.getSound('teleport').play();
				} else if (button.miracleType) {
					// Use stored miracle
					useStoredMiracle(button.miracleIndex);
					self.hide();
					// Teleport hero away from base
					var teleportX = Math.random() * (2048 - 200) + 100;
					var teleportY = Math.random() * (2732 - 400) + 200;
					// Ensure not too close to base
					while (Math.sqrt((teleportX - heroBase.x) * (teleportX - heroBase.x) + (teleportY - heroBase.y) * (teleportY - heroBase.y)) < 300) {
						teleportX = Math.random() * (2048 - 200) + 100;
						teleportY = Math.random() * (2732 - 400) + 200;
					}
					hero.x = teleportX;
					hero.y = teleportY;
					LK.getSound('teleport').play();
				}
				break;
			}
		}
	};
	self.alpha = 0;
	self.scaleX = 0.8;
	self.scaleY = 0.8;
	return self;
});
var MiracleToken = Container.expand(function () {
	var self = Container.call(this);
	var tokenGraphics;
	self.type = 'speed'; // speed, shield, rapidFire, freeze, explosion, healing
	self.bobOffset = Math.random() * Math.PI * 2;
	self.startY = 0;
	self.setTokenType = function (type) {
		self.type = type;
		if (type === 'freeze') {
			tokenGraphics = self.attachAsset('freezeToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'explosion') {
			tokenGraphics = self.attachAsset('explosionToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'healing') {
			tokenGraphics = self.attachAsset('healingToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'hypercharge') {
			tokenGraphics = self.attachAsset('hyperchargeToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'teleport') {
			tokenGraphics = self.attachAsset('teleportToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'invisibility') {
			tokenGraphics = self.attachAsset('invisibilityToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'multiShot') {
			tokenGraphics = self.attachAsset('multiShotToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'timeSlow') {
			tokenGraphics = self.attachAsset('timeSlowToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'timeStop') {
			tokenGraphics = self.attachAsset('timeStopToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'timeRewind') {
			tokenGraphics = self.attachAsset('timeRewindToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'lifeSteal') {
			tokenGraphics = self.attachAsset('lifeStealToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'berserker') {
			tokenGraphics = self.attachAsset('berserkerToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'magnet') {
			tokenGraphics = self.attachAsset('magnetToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'reflect') {
			tokenGraphics = self.attachAsset('reflectToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'phoenix') {
			tokenGraphics = self.attachAsset('phoenixToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'vampire') {
			tokenGraphics = self.attachAsset('vampireToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'godMode') {
			tokenGraphics = self.attachAsset('godModeToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'shadowStrike') {
			tokenGraphics = self.attachAsset('shadowStrikeToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'necromancy') {
			tokenGraphics = self.attachAsset('necromancyToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'aura') {
			tokenGraphics = self.attachAsset('auraToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'chainLightning') {
			tokenGraphics = self.attachAsset('chainLightningToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'summon') {
			tokenGraphics = self.attachAsset('summonToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'meteor') {
			tokenGraphics = self.attachAsset('meteorToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'berserkAura') {
			tokenGraphics = self.attachAsset('berserkAuraToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'dimensionRift') {
			tokenGraphics = self.attachAsset('dimensionRiftToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'divineBlast') {
			tokenGraphics = self.attachAsset('divineBlastToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'apocalypse') {
			tokenGraphics = self.attachAsset('apocalypseToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'titanShield') {
			tokenGraphics = self.attachAsset('titanShieldToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'berserkRage') {
			tokenGraphics = self.attachAsset('berserkRageToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'lightningStorm') {
			tokenGraphics = self.attachAsset('lightningStormToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'bloodRain') {
			tokenGraphics = self.attachAsset('bloodRainToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else {
			tokenGraphics = self.attachAsset('miracleToken', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
	};
	// Initialize with default token
	self.setTokenType('speed');
	self.update = function () {
		// Bobbing animation
		self.y = self.startY + Math.sin(LK.ticks * 0.1 + self.bobOffset) * 10;
		// Rotate
		tokenGraphics.rotation += 0.05;
	};
	return self;
});
var Tiger = Container.expand(function () {
	var self = Container.call(this);
	var tigerGraphics = self.attachAsset('tiger', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 3.5;
	self.damage = 55;
	self.health = 140;
	self.maxHealth = 140;
	self.prowlTimer = 0;
	self.isStealthed = false;
	self.takeDamage = function (damage) {
		self.health -= damage;
		tween(tigerGraphics, {
			tint: 0xff0000
		}, {
			duration: 100
		});
		tween(tigerGraphics, {
			tint: 0xffffff
		}, {
			duration: 100
		});
		if (self.health <= 0) {
			return true;
		}
		return false;
	};
	self.update = function () {
		var dx = hero.x - self.x;
		var dy = hero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.prowlTimer++;
			if (self.prowlTimer > 120 && !self.isStealthed) {
				self.isStealthed = true;
				self.prowlTimer = 0;
				tigerGraphics.alpha = 0.3;
				tween(self, {
					x: hero.x + dx / distance * 200,
					y: hero.y + dy / distance * 200
				}, {
					duration: 800,
					onFinish: function onFinish() {
						self.isStealthed = false;
						tigerGraphics.alpha = 1.0;
					}
				});
			} else if (!self.isStealthed) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
	};
	return self;
});
var TitanBear = Container.expand(function () {
	var self = Container.call(this);
	var titanGraphics = self.attachAsset('bear', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2.5,
		scaleY: 2.5
	});
	titanGraphics.tint = 0x8B0000; // Dark red tint
	self.speed = 0.8;
	self.damage = 40;
	self.health = 150;
	self.maxHealth = 150;
	self.earthQuakeTimer = 0;
	self.roarTimer = 0;
	self.isBoss = true;
	self.takeDamage = function (damage) {
		self.health -= damage;
		createBloodSplatter(self.x, self.y, Math.min(damage / 8, 20));
		tween(titanGraphics, {
			tint: 0xff0000
		}, {
			duration: 150
		});
		tween(titanGraphics, {
			tint: 0x8B0000
		}, {
			duration: 150
		});
		if (self.health <= 0) {
			createBloodSplatter(self.x, self.y, 25);
			return true;
		}
		return false;
	};
	self.update = function () {
		var dx = hero.x - self.x;
		var dy = hero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.earthQuakeTimer++;
			self.roarTimer++;
			// Earthquake attack every 8 seconds
			if (self.earthQuakeTimer > 480) {
				self.earthQuakeTimer = 0;
				// Screen shake effect
				tween(game, {
					x: game.x + 15
				}, {
					duration: 100
				});
				tween(game, {
					x: game.x - 15
				}, {
					duration: 100
				});
				tween(game, {
					x: game.x
				}, {
					duration: 100
				});
				// Damage hero if close
				if (distance < 400) {
					hero.takeDamage(50);
					LK.effects.flashScreen(0x8B4513, 600);
				}
			}
			// Intimidating roar every 5 seconds
			if (self.roarTimer > 300) {
				self.roarTimer = 0;
				LK.effects.flashScreen(0x8B0000, 400);
				// Slow down hero temporarily
				var originalSpeed = hero.speed;
				hero.speed *= 0.5;
				LK.setTimeout(function () {
					hero.speed = originalSpeed;
				}, 2000);
			}
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	return self;
});
var UltiOptiMegaToken = Container.expand(function () {
	var self = Container.call(this);
	var tokenGraphics = self.attachAsset('ultioptimegaToken', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = 'ultioptimega';
	self.bobOffset = Math.random() * Math.PI * 2;
	self.startY = 0;
	// Enhanced visual effects
	tokenGraphics.tint = 0x9900ff; // Purple tint
	self.particleTimer = 0;
	self.update = function () {
		// Enhanced bobbing animation with pulsing effect
		self.y = self.startY + Math.sin(LK.ticks * 0.15 + self.bobOffset) * 15;
		// Pulsing scale animation
		var scale = 1 + Math.sin(LK.ticks * 0.1) * 0.3;
		tokenGraphics.scaleX = scale;
		tokenGraphics.scaleY = scale;
		// Faster rotation
		tokenGraphics.rotation += 0.1;
		// Create particle effects around token
		self.particleTimer++;
		if (self.particleTimer > 10) {
			self.particleTimer = 0;
			createBloodSplatter(self.x + (Math.random() - 0.5) * 60, self.y + (Math.random() - 0.5) * 60, 3);
		}
	};
	return self;
});
var Wolf = Container.expand(function () {
	var self = Container.call(this);
	var wolfGraphics = self.attachAsset('wolf', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 3.2;
	self.damage = 50;
	self.health = 110;
	self.maxHealth = 110;
	self.packTimer = 0;
	self.howlTimer = 0;
	self.lastTrailX = 0;
	self.lastTrailY = 0;
	self.trailTimer = 0;
	self.isWounded = false;
	self.takeDamage = function (damage) {
		self.health -= damage;
		self.isWounded = true;
		// Create blood trail when damaged
		createBloodTrail(self.x, self.y);
		tween(wolfGraphics, {
			tint: 0xff0000
		}, {
			duration: 100
		});
		tween(wolfGraphics, {
			tint: 0xffffff
		}, {
			duration: 100
		});
		if (self.health <= 0) {
			return true;
		}
		return false;
	};
	self.update = function () {
		var dx = hero.x - self.x;
		var dy = hero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.howlTimer++;
			if (self.howlTimer > 150) {
				self.howlTimer = 0;
				for (var i = 0; i < enemies.length; i++) {
					var otherEnemy = enemies[i];
					if (otherEnemy !== self && otherEnemy.type === 'wolf') {
						var dist = Math.sqrt((otherEnemy.x - self.x) * (otherEnemy.x - self.x) + (otherEnemy.y - self.y) * (otherEnemy.y - self.y));
						if (dist < 200) {
							otherEnemy.speed = Math.min(otherEnemy.speed * 1.2, 5.0);
						}
					}
				}
			}
			// Create blood trail if wounded and moving
			if (self.isWounded) {
				self.trailTimer++;
				if (self.trailTimer > 8) {
					// Create trail every 8 frames
					var moveDistance = Math.sqrt((self.x - self.lastTrailX) * (self.x - self.lastTrailX) + (self.y - self.lastTrailY) * (self.y - self.lastTrailY));
					if (moveDistance > 15) {
						createBloodTrail(self.x, self.y);
						self.lastTrailX = self.x;
						self.lastTrailY = self.y;
						self.trailTimer = 0;
					}
				}
			}
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x228B22 // Forest green background
});

/**** 
* Game Code
****/ 
// Sound effects
// UI elements
// Projectiles and power-ups
// Farm animal enemies
// Hero character
// Game state variables
var hero;
var enemies = [];
var bullets = [];
var miracleTokens = [];
var gameState = 'playing'; // playing, gameOver
var currentWave = 1;
var enemiesInWave = 3;
var enemiesSpawned = 0;
var waveSpawnTimer = 0;
var nextWaveTimer = 0;
var miracleTokenCount = 0;
var lastAutoShoot = 0;
var dragNode = null;
var frozenEnemies = [];
var freezeDuration = 0;
var heroBase;
var baseBullets = [];
var bossSpawned = false;
var bloodParticles = [];
var bloodTrails = [];
var miracleMenu;
var controlledAnimal = null;
var controlledAnimalType = '';
var controlledAnimalDuration = 0;
var bossLevels = [1000, 2500, 5000, 8000, 12000];
var currentBossLevel = 0;
var erdo = null;
var erdoLastActivated = 0;
var erdoCooldown = 15000; // 15 seconds cooldown between activations
var erdoRevivalAvailable = false;
var heroRevivalShots = 0;
var heroRevivalShotCooldown = 0;
// UI elements
var healthBar;
var healthBarBg;
var scoreTxt;
var waveTxt;
var miracleCountTxt;
// Initialize UI
function initializeUI() {
	// Health bar background (dark background)
	healthBarBg = LK.getAsset('healthBar', {
		anchorX: 0,
		anchorY: 0,
		tint: 0x333333,
		width: 250,
		height: 30
	});
	// Health bar foreground (actual health)
	healthBar = LK.getAsset('healthBar', {
		anchorX: 0,
		anchorY: 0,
		tint: 0x00ff00,
		width: 240,
		height: 25
	});
	// Health bar border/frame
	var healthBarFrame = LK.getAsset('healthBar', {
		anchorX: 0,
		anchorY: 0,
		tint: 0xffffff,
		width: 250,
		height: 30
	});
	LK.gui.topLeft.addChild(healthBarBg);
	LK.gui.topLeft.addChild(healthBar);
	LK.gui.topLeft.addChild(healthBarFrame);
	healthBarBg.x = 120;
	healthBarBg.y = 20;
	healthBar.x = 125;
	healthBar.y = 22.5;
	healthBarFrame.x = 120;
	healthBarFrame.y = 20;
	// Make frame just an outline
	healthBarFrame.alpha = 0.8;
	// Score text
	scoreTxt = new Text2('Score: 0', {
		size: 60,
		fill: 0xFFFFFF
	});
	scoreTxt.anchor.set(0.5, 0);
	LK.gui.top.addChild(scoreTxt);
	// Wave text
	waveTxt = new Text2('Wave: 1', {
		size: 50,
		fill: 0xFFFF00
	});
	waveTxt.anchor.set(1, 0);
	LK.gui.topRight.addChild(waveTxt);
	waveTxt.x = -20;
	waveTxt.y = 20;
	// Miracle token count
	miracleCountTxt = new Text2('Miracles: 0', {
		size: 45,
		fill: 0xFFD700
	});
	miracleCountTxt.anchor.set(1, 0);
	LK.gui.topRight.addChild(miracleCountTxt);
	miracleCountTxt.x = -20;
	miracleCountTxt.y = 80;
}
// Initialize hero
function initializeHero() {
	hero = game.addChild(new Hero());
	hero.x = 2048 / 2;
	hero.y = 2732 / 2;
}
// Spawn enemy
function spawnEnemy() {
	// Don't spawn enemies during evil erdo battle
	if (evilErdoBattleActive) return;
	var enemy;
	var rand = Math.random();
	// Count current bosses to limit to maximum 1 to prevent crashes
	var currentBossCount = 0;
	for (var i = 0; i < enemies.length; i++) {
		if (enemies[i].isBoss || enemies[i].isOmega) {
			currentBossCount++;
		}
	}
	// Check if boss should spawn at different levels - much more reduced frequency
	var shouldSpawnBoss = false;
	var bossType = 'hyperChicken';
	// Only spawn boss if we have no bosses currently
	if (currentBossCount === 0) {
		// Significantly increase boss spawn thresholds for much less frequent bosses
		var reducedBossLevels = [2000, 4500, 7500, 12000, 18000, 25000, 35000, 50000, 70000, 100000];
		for (var b = 0; b < reducedBossLevels.length; b++) {
			if (LK.getScore() >= reducedBossLevels[b] && currentBossLevel <= b) {
				shouldSpawnBoss = true;
				currentBossLevel = b + 1;
				// More boss variety including wind and magma bosses
				var bossTypes = ['hyperChicken', 'omegaSheep', 'omegaCow', 'omegaChicken', 'omegaPig', 'hyperCow', 'hyperSheep', 'windBoss', 'magmaBoss', 'titanBear'];
				bossType = bossTypes[b % bossTypes.length];
				break;
			}
		}
		// Drastically reduce random boss spawn chance
		if (!shouldSpawnBoss && currentWave >= 8) {
			var bossChance = Math.min(0.015 + currentWave * 0.002, 0.04);
			if (Math.random() < bossChance) {
				shouldSpawnBoss = true;
				var omegaTypes = ['omegaSheep', 'omegaCow', 'omegaChicken', 'omegaPig', 'windBoss', 'magmaBoss', 'titanBear'];
				bossType = omegaTypes[Math.floor(Math.random() * omegaTypes.length)];
			}
		}
	}
	if (shouldSpawnBoss) {
		enemy = new Enemy(bossType);
		// Trigger wind event when wind boss spawns
		if (bossType === 'windBoss') {
			LK.getSound('windevent').play();
			windEventActive = true;
			windEventDuration = 30000; // 30 seconds
		}
		// Trigger magma event when magma boss spawns
		if (bossType === 'magmaBoss') {
			LK.playMusic('magma_event');
			magmaEventActive = true;
			magmaEventDuration = 15000; // 15 seconds - reduced from 30
		}
		// Special spawning for Titan Bear
		if (bossType === 'titanBear') {
			enemy = new TitanBear();
			LK.effects.flashScreen(0x8B0000, 800);
		}
	} else if (currentWave <= 2) {
		enemy = new Enemy('sheep');
	} else if (currentWave <= 4) {
		if (rand < 0.7) {
			enemy = new Enemy('sheep');
		} else {
			enemy = new Enemy('chicken');
		}
	} else {
		// More aggressive spawn distribution with higher chance of stronger enemies
		if (rand < 0.05) {
			enemy = new Enemy('sheep');
		} else if (rand < 0.10) {
			enemy = new Enemy('chicken');
		} else if (rand < 0.15) {
			enemy = new Enemy('cow');
		} else if (rand < 0.20) {
			enemy = new Enemy('chick');
		} else if (rand < 0.25) {
			enemy = new Enemy('snake');
		} else if (rand < 0.30) {
			enemy = new Enemy('mouse');
		} else if (rand < 0.35) {
			enemy = new Enemy('pig');
		} else if (rand < 0.40) {
			enemy = new Enemy('goat');
		} else if (rand < 0.45) {
			enemy = new Enemy('duck');
		} else if (rand < 0.50) {
			enemy = new Enemy('rabbit');
		} else if (rand < 0.65) {
			enemy = new Enemy('hyperSheep');
		} else if (rand < 0.80) {
			enemy = new Enemy('hyperCow');
		} else if (rand < 0.90) {
			enemy = new Enemy('hyperChicken');
		} else if (rand < 0.93) {
			// Add new violent animal types
			enemy = new Lion();
		} else if (rand < 0.96) {
			enemy = new Tiger();
		} else if (rand < 0.98) {
			enemy = new Wolf();
		} else if (rand < 0.995) {
			enemy = new Bear();
		} else {
			enemy = new Elephant();
		}
	}
	// Spawn from random edge
	var side = Math.floor(Math.random() * 4);
	if (side === 0) {
		// Top
		enemy.x = Math.random() * 2048;
		enemy.y = -50;
	} else if (side === 1) {
		// Right
		enemy.x = 2048 + 50;
		enemy.y = Math.random() * 2732;
	} else if (side === 2) {
		// Bottom
		enemy.x = Math.random() * 2048;
		enemy.y = 2732 + 50;
	} else {
		// Left
		enemy.x = -50;
		enemy.y = Math.random() * 2732;
	}
	enemies.push(enemy);
	game.addChild(enemy);
}
// Create bullet towards nearest enemy
function shootAtNearestEnemy() {
	if (enemies.length === 0) return;
	var nearestEnemy = null;
	var nearestDistance = Infinity;
	for (var i = 0; i < enemies.length; i++) {
		var enemy = enemies[i];
		var dx = enemy.x - hero.x;
		var dy = enemy.y - hero.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < nearestDistance) {
			nearestDistance = distance;
			nearestEnemy = enemy;
		}
	}
	if (nearestEnemy) {
		if (hero.explosiveShotMode) {
			// Fire 3 explosive bullets in spread pattern
			for (var i = -1; i <= 1; i++) {
				var bullet = new ExplosiveBullet();
				bullet.x = hero.x;
				bullet.y = hero.y;
				var angle = Math.atan2(nearestEnemy.y - hero.y, nearestEnemy.x - hero.x) + i * 0.25;
				var targetX = hero.x + Math.cos(angle) * 500;
				var targetY = hero.y + Math.sin(angle) * 500;
				bullet.setTarget(targetX, targetY);
				bullets.push(bullet);
				game.addChild(bullet);
			}
		} else if (hero.multiShotMode) {
			// Fire 3 bullets in spread pattern
			for (var i = -1; i <= 1; i++) {
				var bullet = new Bullet();
				bullet.x = hero.x;
				bullet.y = hero.y;
				var angle = Math.atan2(nearestEnemy.y - hero.y, nearestEnemy.x - hero.x) + i * 0.3;
				var targetX = hero.x + Math.cos(angle) * 500;
				var targetY = hero.y + Math.sin(angle) * 500;
				bullet.setTarget(targetX, targetY);
				bullets.push(bullet);
				game.addChild(bullet);
			}
		} else {
			var bullet = new Bullet();
			bullet.x = hero.x;
			bullet.y = hero.y;
			bullet.setTarget(nearestEnemy.x, nearestEnemy.y);
			bullets.push(bullet);
			game.addChild(bullet);
		}
		LK.getSound('shoot').play();
	}
}
// Create blood splatter effect
function createBloodSplatter(x, y, intensity) {
	// Drastically limit blood particles to prevent crashes
	if (bloodParticles.length > 20) return;
	intensity = intensity || 3;
	// Significantly reduce intensity to prevent memory overflow
	intensity = Math.min(intensity, 4);
	// Only create blood effects every few frames to reduce load
	if (LK.ticks % 3 !== 0) return;
	for (var i = 0; i < intensity; i++) {
		var blood = new BloodParticle();
		blood.x = x + (Math.random() - 0.5) * 40;
		blood.y = y + (Math.random() - 0.5) * 40;
		// Reduce velocity variation
		blood.velocityX = (Math.random() - 0.5) * 12;
		blood.velocityY = (Math.random() - 0.5) * 12;
		// Much shorter life to free memory faster
		blood.life = 30;
		blood.maxLife = 30;
		bloodParticles.push(blood);
		game.addChild(blood);
	}
	// Remove screen shake to reduce processing
}
// Create blood trail effect
function createBloodTrail(x, y) {
	// Drastically limit blood trails to prevent crashes
	if (bloodTrails.length > 15) return;
	// Only create trails every few frames to reduce load
	if (LK.ticks % 5 !== 0) return;
	var trail = new BloodTrail();
	trail.x = x + (Math.random() - 0.5) * 10;
	trail.y = y + (Math.random() - 0.5) * 10;
	bloodTrails.push(trail);
	game.addChild(trail);
}
// Create miracle token
function createMiracleToken(x, y) {
	var token = new MiracleToken();
	token.x = x;
	token.y = y;
	token.startY = y;
	var rand = Math.random();
	if (rand < 0.05) {
		token.setTokenType('speed');
	} else if (rand < 0.10) {
		token.setTokenType('shield');
	} else if (rand < 0.15) {
		token.setTokenType('rapidFire');
	} else if (rand < 0.20) {
		token.setTokenType('freeze');
	} else if (rand < 0.25) {
		token.setTokenType('explosion');
	} else if (rand < 0.30) {
		token.setTokenType('healing');
	} else if (rand < 0.35) {
		token.setTokenType('hypercharge');
	} else if (rand < 0.40) {
		token.setTokenType('teleport');
	} else if (rand < 0.45) {
		token.setTokenType('invisibility');
	} else if (rand < 0.50) {
		token.setTokenType('multiShot');
	} else if (rand < 0.55) {
		token.setTokenType('timeSlow');
	} else if (rand < 0.60) {
		token.setTokenType('timeStop');
	} else if (rand < 0.65) {
		token.setTokenType('timeRewind');
	} else if (rand < 0.70) {
		token.setTokenType('lifeSteal');
	} else if (rand < 0.75) {
		token.setTokenType('berserker');
	} else if (rand < 0.80) {
		token.setTokenType('magnet');
	} else if (rand < 0.85) {
		token.setTokenType('reflect');
	} else if (rand < 0.90) {
		token.setTokenType('phoenix');
	} else if (rand < 0.87) {
		token.setTokenType('vampire');
	} else if (rand < 0.885) {
		token.setTokenType('shadowStrike');
	} else if (rand < 0.90) {
		token.setTokenType('necromancy');
	} else if (rand < 0.915) {
		token.setTokenType('aura');
	} else if (rand < 0.93) {
		token.setTokenType('chainLightning');
	} else if (rand < 0.945) {
		token.setTokenType('summon');
	} else if (rand < 0.96) {
		token.setTokenType('meteor');
	} else if (rand < 0.975) {
		token.setTokenType('berserkAura');
	} else if (rand < 0.987) {
		token.setTokenType('dimensionRift');
	} else if (rand < 0.995) {
		token.setTokenType('divineBlast');
	} else if (rand < 0.997) {
		token.setTokenType('apocalypse');
	} else if (rand < 0.9975) {
		token.setTokenType('titanShield');
	} else if (rand < 0.998) {
		token.setTokenType('berserkRage');
	} else if (rand < 0.9985) {
		token.setTokenType('lightningStorm');
	} else if (rand < 0.999) {
		token.setTokenType('bloodRain');
	} else {
		token.setTokenType('godMode');
	}
	miracleTokens.push(token);
	game.addChild(token);
}
// Freeze all enemies
function freezeEnemies() {
	freezeDuration = 3000; // 3 seconds
	for (var i = 0; i < enemies.length; i++) {
		enemies[i].frozenSpeed = enemies[i].speed;
		enemies[i].speed = 0;
		enemies[i].isFrozen = true;
		// Visual effect - tint blue
		tween(enemies[i], {
			tint: 0x0088ff
		}, {
			duration: 200
		});
	}
}
// Explode nearby enemies
function explodeNearbyEnemies() {
	var explosionRadius = 200;
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		var dx = enemy.x - hero.x;
		var dy = enemy.y - hero.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance <= explosionRadius) {
			// Create explosion effect
			LK.effects.flashObject(enemy, 0xff4400, 300);
			var enemyDied = enemy.takeDamage(50);
			if (enemyDied) {
				LK.setScore(LK.getScore() + 10);
				scoreTxt.setText('Score: ' + LK.getScore());
				enemy.destroy();
				enemies.splice(i, 1);
			}
		}
	}
}
// Revival explosion effect
function createRevivalExplosion() {
	var explosionRadius = 300;
	// Create massive visual explosion
	LK.effects.flashScreen(0xffaa00, 1000);
	// Create blood splatters around hero
	for (var i = 0; i < 20; i++) {
		createBloodSplatter(hero.x + (Math.random() - 0.5) * 200, hero.y + (Math.random() - 0.5) * 200, 15);
	}
	// Damage and freeze nearby enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		var dx = enemy.x - hero.x;
		var dy = enemy.y - hero.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance <= explosionRadius) {
			// Damage enemy
			var enemyDied = enemy.takeDamage(30);
			if (enemyDied) {
				LK.setScore(LK.getScore() + 10);
				scoreTxt.setText('Score: ' + LK.getScore());
				enemy.destroy();
				enemies.splice(i, 1);
				continue;
			}
			// Freeze enemy for 8 seconds
			enemy.frozenSpeed = enemy.speed;
			enemy.speed = 0;
			enemy.isFrozen = true;
			enemy.freezeTimer = 8000; // 8 seconds
			tween(enemy, {
				tint: 0x0088ff
			}, {
				duration: 200
			});
		}
	}
}
// Handle move events
function handleMove(x, y, obj) {
	if (gameState !== 'playing' || gamePaused) return;
	if (dragNode) {
		// Keep hero within bounds
		dragNode.x = Math.max(40, Math.min(2048 - 40, x));
		dragNode.y = Math.max(40, Math.min(2732 - 40, y));
	}
	// Control animal if active
	if (controlledAnimal && !dragNode) {
		controlledAnimal.x = Math.max(40, Math.min(2048 - 40, x));
		controlledAnimal.y = Math.max(40, Math.min(2732 - 40, y));
	}
}
// Touch/mouse events
game.move = handleMove;
game.down = function (x, y, obj) {
	// Handle revival button click first
	if (gameState === 'revivalOption' && handleRevivalClick(x, y)) {
		return;
	}
	// Handle miracle menu clicks
	if (miracleMenu.isVisible) {
		miracleMenu.down(x, y, obj);
		return;
	}
	// Handle storage UI clicks
	if (handleStorageClick(x, y)) {
		return;
	}
	if (gameState !== 'playing' || gamePaused) return;
	dragNode = hero;
	handleMove(x, y, obj);
};
game.up = function (x, y, obj) {
	dragNode = null;
};
// Initialize base
function initializeBase() {
	heroBase = game.addChild(new HeroBase());
	heroBase.x = 2048 / 2;
	heroBase.y = 2732 - 200;
	heroBase.initializeTurrets();
}
// Initialize game
initializeUI();
initializeHero();
initializeBase();
// Initialize miracle storage
loadStoredMiracles();
updateStoredMiraclesUI();
// Initialize miracle menu
miracleMenu = game.addChild(new MiracleMenu());
miracleMenu.x = 2048 / 2;
miracleMenu.y = 2732 / 2;
// Initialize Erdo helper
erdo = game.addChild(new Erdo());
// Initialize Evil Erdo
evilErdo = game.addChild(new EvilErdo());
// Play farm war music
LK.playMusic('farm_war');
// Main game update loop
game.update = function () {
	if (gameState !== 'playing') return;
	// Update hero
	hero.update();
	// Update controlled animal
	if (controlledAnimal) {
		controlledAnimal.update();
		controlledAnimalDuration -= 16.67;
		if (controlledAnimalDuration <= 0) {
			controlledAnimal.destroy();
			controlledAnimal = null;
			controlledAnimalType = '';
		}
	}
	// Create controlled animal if type selected
	if (controlledAnimalType !== '' && controlledAnimal === null) {
		controlledAnimal = game.addChild(new ControlledAnimal(controlledAnimalType));
		controlledAnimal.x = heroBase.x;
		controlledAnimal.y = heroBase.y - 50;
	}
	// Update base
	heroBase.update();
	// Check if hero is in safe zone
	var heroInSafeZone = heroBase.isHeroInSafeZone(hero.x, hero.y);
	// Base interaction system - access stored miracles when in base
	if (heroInSafeZone) {
		// Show miracle menu when entering base
		if (!miracleMenu.isVisible) {
			miracleMenu.show();
		}
		// Show stored miracles UI with enhanced visibility
		if (storedMiracles.length > 0) {
			for (var i = 0; i < storedMiraclesUI.length; i++) {
				if (storedMiraclesUI[i]) {
					storedMiraclesUI[i].alpha = 1.0;
					storedMiraclesUI[i].scaleX = 1.2;
					storedMiraclesUI[i].scaleY = 1.2;
				}
			}
			// Add pulsing effect to indicate availability
			if (storageText) {
				storageText.alpha = 0.8 + Math.sin(LK.ticks * 0.1) * 0.2;
				storageText.setText('STORED MIRACLES - CLICK TO USE (' + storedMiracles.length + '/' + maxStoredMiracles + ')');
			}
		}
	} else {
		// Hide miracle menu when leaving base
		if (miracleMenu.isVisible) {
			miracleMenu.hide();
		}
		// Reset UI when not in base
		for (var i = 0; i < storedMiraclesUI.length; i++) {
			if (storedMiraclesUI[i]) {
				storedMiraclesUI[i].alpha = 0.7;
				storedMiraclesUI[i].scaleX = 0.7;
				storedMiraclesUI[i].scaleY = 0.7;
			}
		}
		if (storageText) {
			storageText.alpha = 1.0;
			storageText.setText('STORED MIRACLES (' + storedMiracles.length + '/' + maxStoredMiracles + ')');
		}
	}
	// Update freeze duration
	if (freezeDuration > 0) {
		freezeDuration -= 16.67; // Approximately 60fps
		if (freezeDuration <= 0) {
			// Unfreeze all enemies
			for (var i = 0; i < enemies.length; i++) {
				if (enemies[i].isFrozen) {
					enemies[i].speed = enemies[i].frozenSpeed;
					enemies[i].isFrozen = false;
					// Remove blue tint
					tween(enemies[i], {
						tint: 0xffffff
					}, {
						duration: 200
					});
				}
			}
		}
	}
	// Update health bar
	var healthPercent = hero.health / hero.maxHealth;
	healthBar.width = 240 * healthPercent;
	// Update health bar color based on health percentage
	if (healthPercent > 0.6) {
		healthBar.tint = 0x00ff00; // Green
	} else if (healthPercent > 0.3) {
		healthBar.tint = 0xffff00; // Yellow
	} else {
		healthBar.tint = 0xff0000; // Red
	}
	// Add pulsing effect when health is low
	if (healthPercent <= 0.25) {
		var pulseAlpha = 0.5 + Math.sin(LK.ticks * 0.2) * 0.3;
		healthBar.alpha = pulseAlpha;
	} else {
		healthBar.alpha = 1.0;
	}
	// Activate Erdo when hero health is low
	if (healthPercent <= 0.3 && !erdo.isActive && LK.ticks - erdoLastActivated > erdoCooldown / 16.67) {
		erdo.activate();
		erdoLastActivated = LK.ticks;
		erdoRevivalAvailable = true;
	}
	// Update Erdo
	if (erdo) {
		erdo.update();
	}
	// Update Evil Erdo
	if (evilErdo && evilErdoBattleActive) {
		evilErdo.update();
		// Check if evil erdo is defeated
		if (evilErdo.health <= 0 && evilErdoBattleActive) {
			evilErdoBattleActive = false;
			evilErdo.visible = false;
			evilErdo.isActive = false;
			// Grant massive score bonus
			LK.setScore(LK.getScore() + 1000);
			scoreTxt.setText('Score: ' + LK.getScore());
			// Create victory explosion
			createBloodSplatter(evilErdo.x, evilErdo.y, 50);
			LK.effects.flashScreen(0xFFD700, 1500);
			// Grant hero powerful temporary abilities
			hero.hasShield = true;
			hero.shieldDuration = 10000;
			hero.explosiveShotMode = true;
			hero.explosiveShotDuration = 15000;
			hero.rapidShootCooldown = 100;
			hero.shootCooldown = hero.rapidShootCooldown;
			LK.getSound('powerUp').play();
		}
	}
	// Handle revival 5-shot system
	if (heroRevivalShots > 0) {
		heroRevivalShotCooldown -= 16.67;
		if (heroRevivalShotCooldown <= 0) {
			// Shoot 5 bullets in spread pattern
			for (var i = -2; i <= 2; i++) {
				var bullet = new Bullet();
				bullet.x = hero.x;
				bullet.y = hero.y;
				var angle = Math.atan2(-1, 0) + i * 0.4; // Spread upward
				var targetX = hero.x + Math.cos(angle) * 500;
				var targetY = hero.y + Math.sin(angle) * 500;
				bullet.setTarget(targetX, targetY);
				bullet.speed = 12;
				bullets.push(bullet);
				game.addChild(bullet);
			}
			LK.getSound('shoot').play();
			heroRevivalShots--;
			heroRevivalShotCooldown = 700; // 0.7 seconds between shots
		}
	} else {
		// Auto shoot
		if (LK.ticks - lastAutoShoot > hero.shootCooldown / 16.67) {
			shootAtNearestEnemy();
			lastAutoShoot = LK.ticks;
		}
	}
	// Wave spawning - limit enemies to prevent crashes (not during evil erdo battle)
	if (!evilErdoBattleActive && enemiesSpawned < enemiesInWave && enemies.length < 30) {
		waveSpawnTimer++;
		if (waveSpawnTimer >= 45) {
			// Spawn every 0.75 seconds - slower to reduce load
			spawnEnemy();
			// Reduce multiple enemy spawning
			if (currentWave >= 8 && enemies.length < 20) {
				spawnEnemy();
			}
			if (currentWave >= 15 && enemies.length < 15) {
				spawnEnemy();
			}
			enemiesSpawned++;
			waveSpawnTimer = 0;
		}
	}
	// Check for next wave
	if (enemiesSpawned >= enemiesInWave && enemies.length === 0) {
		nextWaveTimer++;
		if (nextWaveTimer >= 120) {
			// 2 second delay
			currentWave++;
			enemiesInWave = 3 + currentWave;
			enemiesSpawned = 0;
			nextWaveTimer = 0;
			waveTxt.setText('Wave: ' + currentWave);
		}
	}
	// Update enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		// Handle revival freeze timer
		if (enemy.freezeTimer !== undefined && enemy.freezeTimer > 0) {
			enemy.freezeTimer -= 16.67;
			if (enemy.freezeTimer <= 0) {
				enemy.speed = enemy.frozenSpeed;
				enemy.isFrozen = false;
				enemy.freezeTimer = undefined;
				tween(enemy, {
					tint: 0xffffff
				}, {
					duration: 200
				});
			}
		}
		// Apply time effects to enemy movement
		if (!timeStopActive) {
			var originalSpeed = enemy.speed;
			enemy.speed *= timeSlowFactor;
			enemy.update();
			enemy.speed = originalSpeed;
		}
		// Check collision with controlled animal
		if (controlledAnimal && enemy.intersects(controlledAnimal) && enemy.type !== controlledAnimal.type) {
			var animalDied = controlledAnimal.takeDamage(enemy.damage);
			if (animalDied) {
				controlledAnimal.destroy();
				controlledAnimal = null;
				controlledAnimalType = '';
				controlledAnimalDuration = 0;
			}
			enemy.destroy();
			enemies.splice(i, 1);
			continue;
		}
		// Check collision with evil erdo
		if (evilErdoBattleActive && evilErdo.intersects(hero) && !hero.invisibilityMode && !heroInSafeZone) {
			var heroDied = hero.takeDamage(evilErdo.damage);
			if (heroDied) {
				gameState = 'gameOver';
				LK.showGameOver();
				return;
			}
			LK.effects.flashScreen(0x800080, 300);
		}
		// Check collision with hero (only if not in safe zone)
		if (!evilErdoBattleActive && enemy.intersects(hero) && !hero.invisibilityMode && !heroInSafeZone) {
			var heroDied = hero.takeDamage(enemy.damage);
			if (heroDied) {
				if (erdoRevivalAvailable) {
					// Show revival option instead of immediate game over
					gameState = 'revivalOption';
					showRevivalButton();
					return;
				} else {
					gameState = 'gameOver';
					LK.showGameOver();
					return;
				}
			}
			// Remove enemy after collision
			enemy.destroy();
			enemies.splice(i, 1);
			LK.effects.flashScreen(0xff0000, 500);
			continue;
		}
		// Remove enemies that are too far off screen
		if (enemy.x < -200 || enemy.x > 2248 || enemy.y < -200 || enemy.y > 2932) {
			enemy.destroy();
			enemies.splice(i, 1);
		}
	}
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		bullet.update();
		// Check collision with evil erdo first
		if (evilErdoBattleActive && bullet.intersects(evilErdo)) {
			var evilErdoDied = evilErdo.takeDamage(bullet.damage);
			bullet.destroy();
			bullets.splice(i, 1);
			if (evilErdoDied) {
				// Evil erdo defeated - handled in main update loop
			}
			continue;
		}
		// Check collision with enemies
		var hitEnemy = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (bullet.intersects(enemy)) {
				// Check if it's an explosive bullet
				if (bullet.explode) {
					bullet.explode(); // Trigger explosion effect
				}
				var enemyDied = enemy.takeDamage(bullet.damage);
				// Life steal and vampire healing
				if (hero.lifeStealMode || hero.vampireMode) {
					var healAmount = Math.min(bullet.damage * 0.15, 8);
					hero.health = Math.min(hero.health + healAmount, hero.maxHealth);
					LK.effects.flashObject(hero, 0x00ff00, 100);
				}
				if (enemyDied) {
					// Additional vampire healing on kill
					if (hero.vampireMode) {
						hero.health = Math.min(hero.health + 20, hero.maxHealth);
					}
					// Create UltiOptiMega token when boss is killed
					if (enemy.isBoss || enemy.isOmega) {
						var ultiToken = new UltiOptiMegaToken();
						ultiToken.x = enemy.x;
						ultiToken.y = enemy.y;
						ultiToken.startY = enemy.y;
						miracleTokens.push(ultiToken);
						game.addChild(ultiToken);
						LK.effects.flashScreen(0x9900ff, 800);
						// End magma event when magma boss is killed
						if (enemy.type === 'magmaBoss' && magmaEventActive) {
							magmaEventActive = false;
							magmaEventDuration = 0;
							// Restore normal music
							LK.playMusic('farm_war');
						}
					}
					// Create miracle token chance
					if (Math.random() < 0.55) {
						// 55% chance
						createMiracleToken(enemy.x, enemy.y);
					}
					var scoreIncrease = enemy.isBoss ? 100 : 10;
					LK.setScore(LK.getScore() + scoreIncrease);
					scoreTxt.setText('Score: ' + LK.getScore());
					enemy.destroy();
					enemies.splice(j, 1);
					LK.getSound('enemyHit').play();
				}
				bullet.destroy();
				bullets.splice(i, 1);
				hitEnemy = true;
				break;
			}
		}
		if (hitEnemy) continue;
		// Remove bullets that are off screen
		if (bullet.x < -50 || bullet.x > 2098 || bullet.y < -50 || bullet.y > 2782) {
			bullet.destroy();
			bullets.splice(i, 1);
		}
	}
	// Update base bullets
	for (var i = baseBullets.length - 1; i >= 0; i--) {
		var bullet = baseBullets[i];
		bullet.update();
		// Check collision with enemies
		var hitEnemy = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (bullet.intersects(enemy)) {
				var enemyDied = enemy.takeDamage(bullet.damage);
				if (enemyDied) {
					// Create miracle token chance
					if (Math.random() < 0.3) {
						createMiracleToken(enemy.x, enemy.y);
					}
					var scoreIncrease = enemy.isBoss ? 100 : 10;
					LK.setScore(LK.getScore() + scoreIncrease);
					scoreTxt.setText('Score: ' + LK.getScore());
					enemy.destroy();
					enemies.splice(j, 1);
					LK.getSound('enemyHit').play();
				}
				bullet.destroy();
				baseBullets.splice(i, 1);
				hitEnemy = true;
				break;
			}
		}
		if (hitEnemy) continue;
		// Remove bullets that are off screen
		if (bullet.x < -50 || bullet.x > 2098 || bullet.y < -50 || bullet.y > 2782) {
			bullet.destroy();
			baseBullets.splice(i, 1);
		}
	}
	// Update blood particles - cleanup aggressively
	for (var i = bloodParticles.length - 1; i >= 0; i--) {
		var blood = bloodParticles[i];
		blood.update();
		if (blood.life <= 0) {
			blood.destroy();
			bloodParticles.splice(i, 1);
		}
	}
	// Force cleanup if too many particles
	if (bloodParticles.length > 25) {
		for (var i = 0; i < 10; i++) {
			if (bloodParticles[i]) {
				bloodParticles[i].destroy();
				bloodParticles.splice(i, 1);
			}
		}
	}
	// Update blood trails - cleanup aggressively
	for (var i = bloodTrails.length - 1; i >= 0; i--) {
		var trail = bloodTrails[i];
		trail.update();
		if (trail.life <= 0) {
			trail.destroy();
			bloodTrails.splice(i, 1);
		}
	}
	// Force cleanup if too many trails
	if (bloodTrails.length > 20) {
		for (var i = 0; i < 5; i++) {
			if (bloodTrails[i]) {
				bloodTrails[i].destroy();
				bloodTrails.splice(i, 1);
			}
		}
	}
	// Update miracle tokens
	for (var i = miracleTokens.length - 1; i >= 0; i--) {
		var token = miracleTokens[i];
		token.update();
		// Check collision with hero
		if (token.intersects(hero)) {
			miracleTokenCount++;
			miracleCountTxt.setText('Miracles: ' + miracleTokenCount);
			// Check if storage is available and hero is holding down
			if (dragNode && storedMiracles.length < maxStoredMiracles) {
				// Store the miracle instead of using it
				var stored = addMiracleToStorage(token.type);
				if (stored) {
					LK.getSound('tokenCollect').play();
					token.destroy();
					miracleTokens.splice(i, 1);
					continue;
				}
			}
			// Activate power-up immediately
			activateMiraclePower(token.type);
			LK.getSound('tokenCollect').play();
			token.destroy();
			miracleTokens.splice(i, 1);
		}
	}
	// Handle special miracle effects
	if (hero.magnetMode) {
		// Attract nearby miracle tokens
		for (var i = 0; i < miracleTokens.length; i++) {
			var token = miracleTokens[i];
			var dx = hero.x - token.x;
			var dy = hero.y - token.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < 200 && distance > 0) {
				token.x += dx / distance * 8;
				token.y += dy / distance * 8;
			}
		}
	}
	// Handle phoenix revival
	if (hero.phoenixMode && hero.health <= 0) {
		hero.health = hero.maxHealth;
		hero.phoenixMode = false;
		hero.phoenixDuration = 0;
		createRevivalExplosion();
		LK.effects.flashObject(hero, 0xFF6347, 1000);
	}
	// Handle reflect damage
	if (hero.reflectMode) {
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			if (enemy.intersects(hero)) {
				var enemyDied = enemy.takeDamage(enemy.damage);
				if (enemyDied) {
					LK.setScore(LK.getScore() + 10);
					scoreTxt.setText('Score: ' + LK.getScore());
					enemy.destroy();
					enemies.splice(i, 1);
				}
				LK.effects.flashObject(enemy, 0x9932CC, 200);
			}
		}
	}
	// Handle shadow strike - teleport behind enemies and deal massive damage
	if (hero.shadowStrikeMode && LK.ticks % 180 === 0 && enemies.length > 0) {
		var targetEnemy = enemies[Math.floor(Math.random() * enemies.length)];
		hero.x = targetEnemy.x + 80;
		hero.y = targetEnemy.y + 80;
		var enemyDied = targetEnemy.takeDamage(100);
		if (enemyDied) {
			LK.setScore(LK.getScore() + 10);
			scoreTxt.setText('Score: ' + LK.getScore());
			targetEnemy.destroy();
			enemies.splice(enemies.indexOf(targetEnemy), 1);
		}
		LK.effects.flashObject(hero, 0x2f1b69, 300);
	}
	// Handle necromancy - revive dead enemies as allies
	if (hero.necromancyMode && LK.ticks % 300 === 0) {
		for (var i = 0; i < 2; i++) {
			var reviveBuddy = game.addChild(new ControlledAnimal('sheep'));
			reviveBuddy.x = hero.x + (Math.random() - 0.5) * 200;
			reviveBuddy.y = hero.y + (Math.random() - 0.5) * 200;
			reviveBuddy.health = 200;
			reviveBuddy.damage = 50;
		}
	}
	// Handle aura - heal hero and boost nearby allies
	if (hero.auraMode && LK.ticks % 60 === 0) {
		hero.health = Math.min(hero.health + 5, hero.maxHealth);
		if (controlledAnimal) {
			controlledAnimal.health = Math.min(controlledAnimal.health + 10, controlledAnimal.maxHealth);
		}
		LK.effects.flashObject(hero, 0xffd43b, 100);
	}
	// Handle chain lightning - damage multiple enemies in chain
	if (hero.chainLightningMode && LK.ticks % 120 === 0 && enemies.length > 0) {
		var lightningTargets = enemies.slice(0, Math.min(5, enemies.length));
		for (var i = 0; i < lightningTargets.length; i++) {
			var enemy = lightningTargets[i];
			var enemyDied = enemy.takeDamage(60);
			if (enemyDied) {
				LK.setScore(LK.getScore() + 10);
				scoreTxt.setText('Score: ' + LK.getScore());
				enemy.destroy();
				enemies.splice(enemies.indexOf(enemy), 1);
			}
			LK.effects.flashObject(enemy, 0x4a90e2, 200);
		}
	}
	// Handle summon - spawn protective creatures
	if (hero.summonMode && LK.ticks % 600 === 0) {
		for (var i = 0; i < 3; i++) {
			var summonedCreature = game.addChild(new ControlledAnimal('chicken'));
			summonedCreature.x = hero.x + Math.cos(i * 2.09) * 100;
			summonedCreature.y = hero.y + Math.sin(i * 2.09) * 100;
			summonedCreature.health = 150;
			summonedCreature.damage = 40;
		}
	}
	// Handle meteor - random devastating strikes from sky
	if (hero.meteorMode && LK.ticks % 180 === 0) {
		var meteorX = Math.random() * 2048;
		var meteorY = Math.random() * 2732;
		var meteorRadius = 150;
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var dx = enemy.x - meteorX;
			var dy = enemy.y - meteorY;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= meteorRadius) {
				var enemyDied = enemy.takeDamage(120);
				if (enemyDied) {
					LK.setScore(LK.getScore() + 10);
					scoreTxt.setText('Score: ' + LK.getScore());
					enemy.destroy();
					enemies.splice(i, 1);
				}
			}
		}
		LK.effects.flashScreen(0xd0021b, 200);
		createBloodSplatter(meteorX, meteorY, 20);
	}
	// Handle berserk aura - boost all allies damage and speed
	if (hero.berserkAuraMode && LK.ticks % 90 === 0) {
		if (controlledAnimal) {
			controlledAnimal.speed = Math.min(controlledAnimal.speed * 1.1, 8);
			controlledAnimal.damage = Math.min(controlledAnimal.damage * 1.1, 80);
		}
		LK.effects.flashObject(hero, 0xf5a623, 150);
	}
	// Handle dimension rift - teleport enemies to random locations
	if (hero.dimensionRiftMode && LK.ticks % 240 === 0) {
		for (var i = 0; i < Math.min(3, enemies.length); i++) {
			var enemy = enemies[i];
			enemy.x = Math.random() * 2048;
			enemy.y = Math.random() * 2732;
			LK.effects.flashObject(enemy, 0x9013fe, 300);
		}
	}
	// Handle divine blast - massive holy damage to all enemies
	if (hero.divineBlastMode && LK.ticks % 300 === 0) {
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var enemyDied = enemy.takeDamage(80);
			if (enemyDied) {
				LK.setScore(LK.getScore() + 10);
				scoreTxt.setText('Score: ' + LK.getScore());
				enemy.destroy();
				enemies.splice(i, 1);
			}
			LK.effects.flashObject(enemy, 0xffffff, 500);
		}
		LK.effects.flashScreen(0xffffff, 300);
	}
	// Handle apocalypse - screen-wide devastation
	if (hero.apocalypseMode && LK.ticks % 360 === 0) {
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var enemyDied = enemy.takeDamage(150);
			if (enemyDied) {
				LK.setScore(LK.getScore() + 15);
				scoreTxt.setText('Score: ' + LK.getScore());
				enemy.destroy();
				enemies.splice(i, 1);
			}
		}
		LK.effects.flashScreen(0x000000, 800);
		createBloodSplatter(2048 / 2, 2732 / 2, 30);
	}
	// Handle lightning storm - continuous lightning strikes
	if (hero.lightningStormMode && LK.ticks % 60 === 0) {
		for (var i = 0; i < 3; i++) {
			var lightningX = Math.random() * 2048;
			var lightningY = Math.random() * 2732;
			var lightningRadius = 100;
			for (var j = enemies.length - 1; j >= 0; j--) {
				var enemy = enemies[j];
				var dx = enemy.x - lightningX;
				var dy = enemy.y - lightningY;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance <= lightningRadius) {
					var enemyDied = enemy.takeDamage(90);
					if (enemyDied) {
						LK.setScore(LK.getScore() + 10);
						scoreTxt.setText('Score: ' + LK.getScore());
						enemy.destroy();
						enemies.splice(j, 1);
					}
				}
			}
			LK.effects.flashScreen(0xffff00, 150);
		}
	}
	// Handle blood rain - constant damage to all enemies
	if (hero.bloodRainMode && LK.ticks % 90 === 0) {
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var enemyDied = enemy.takeDamage(35);
			if (enemyDied) {
				LK.setScore(LK.getScore() + 10);
				scoreTxt.setText('Score: ' + LK.getScore());
				enemy.destroy();
				enemies.splice(i, 1);
			}
			createBloodSplatter(enemy.x, enemy.y, 8);
		}
		LK.effects.flashScreen(0x8b0000, 100);
	}
	// Handle void walker - phase through enemies and deal damage
	if (hero.voidWalkerMode && LK.ticks % 30 === 0) {
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var dx = hero.x - enemy.x;
			var dy = hero.y - enemy.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < 150) {
				var enemyDied = enemy.takeDamage(200);
				if (enemyDied) {
					LK.setScore(LK.getScore() + 15);
					scoreTxt.setText('Score: ' + LK.getScore());
					enemy.destroy();
					enemies.splice(i, 1);
				}
				LK.effects.flashObject(enemy, 0x1a0033, 200);
			}
		}
	}
	// Handle cosmic rage - screen-wide devastation with cosmic energy
	if (hero.cosmicRageMode && LK.ticks % 120 === 0) {
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var enemyDied = enemy.takeDamage(300);
			if (enemyDied) {
				LK.setScore(LK.getScore() + 20);
				scoreTxt.setText('Score: ' + LK.getScore());
				enemy.destroy();
				enemies.splice(i, 1);
			}
			LK.effects.flashObject(enemy, 0xff0099, 300);
		}
		LK.effects.flashScreen(0xff0099, 300);
		createBloodSplatter(2048 / 2, 2732 / 2, 40);
	}
	// Handle soul harvest - drain life from all enemies
	if (hero.soulHarvestMode && LK.ticks % 90 === 0) {
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			var soulDrain = Math.min(enemy.health * 0.1, 50);
			enemy.takeDamage(soulDrain);
			hero.health = Math.min(hero.health + soulDrain * 0.5, hero.maxHealth);
			LK.effects.flashObject(enemy, 0x660066, 150);
		}
		LK.effects.flashObject(hero, 0x00ff00, 100);
	}
	// Handle elemental fury - constant elemental explosions
	if (hero.elementalFuryMode && LK.ticks % 45 === 0) {
		for (var i = 0; i < 8; i++) {
			var elementX = Math.random() * 2048;
			var elementY = Math.random() * 2732;
			var elementRadius = 180;
			for (var j = enemies.length - 1; j >= 0; j--) {
				var enemy = enemies[j];
				var dx = enemy.x - elementX;
				var dy = enemy.y - elementY;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance <= elementRadius) {
					var enemyDied = enemy.takeDamage(150);
					if (enemyDied) {
						LK.setScore(LK.getScore() + 15);
						scoreTxt.setText('Score: ' + LK.getScore());
						enemy.destroy();
						enemies.splice(j, 1);
					}
				}
			}
			LK.effects.flashScreen(0xff6600, 100);
			createBloodSplatter(elementX, elementY, 25);
		}
	}
	// Handle quantum leap - teleport and create quantum explosions
	if (hero.quantumLeapMode && LK.ticks % 180 === 0) {
		// Teleport to random location
		hero.x = Math.random() * 1800 + 124;
		hero.y = Math.random() * 2400 + 166;
		// Create quantum explosion at new location
		var quantumRadius = 250;
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var dx = enemy.x - hero.x;
			var dy = enemy.y - hero.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= quantumRadius) {
				var enemyDied = enemy.takeDamage(250);
				if (enemyDied) {
					LK.setScore(LK.getScore() + 20);
					scoreTxt.setText('Score: ' + LK.getScore());
					enemy.destroy();
					enemies.splice(i, 1);
				}
			}
		}
		LK.effects.flashScreen(0x00ff99, 400);
		createBloodSplatter(hero.x, hero.y, 35);
	}
	// Handle dragon breath - continuous fire streams
	if (hero.dragonBreathMode && LK.ticks % 30 === 0) {
		var breathAngle = LK.ticks * 0.1;
		for (var i = 0; i < 12; i++) {
			var angle = breathAngle + i * (Math.PI * 2 / 12);
			var breathX = hero.x + Math.cos(angle) * 200;
			var breathY = hero.y + Math.sin(angle) * 200;
			for (var j = enemies.length - 1; j >= 0; j--) {
				var enemy = enemies[j];
				var dx = enemy.x - breathX;
				var dy = enemy.y - breathY;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance <= 80) {
					var enemyDied = enemy.takeDamage(120);
					if (enemyDied) {
						LK.setScore(LK.getScore() + 15);
						scoreTxt.setText('Score: ' + LK.getScore());
						enemy.destroy();
						enemies.splice(j, 1);
					}
					LK.effects.flashObject(enemy, 0xff3300, 150);
				}
			}
			createBloodSplatter(breathX, breathY, 8);
		}
	}
	// Handle arcane storm - magical energy waves
	if (hero.arcaneStormMode && LK.ticks % 75 === 0) {
		var waveRadius = LK.ticks % 600 * 2;
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var dx = enemy.x - hero.x;
			var dy = enemy.y - hero.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (Math.abs(distance - waveRadius) <= 50) {
				var enemyDied = enemy.takeDamage(180);
				if (enemyDied) {
					LK.setScore(LK.getScore() + 15);
					scoreTxt.setText('Score: ' + LK.getScore());
					enemy.destroy();
					enemies.splice(i, 1);
				}
				LK.effects.flashObject(enemy, 0x9933ff, 200);
			}
		}
	}
	// Handle galaxy collapse - pull all enemies to center and crush
	if (hero.galaxyCollapseMode && LK.ticks % 120 === 0) {
		var centerX = 2048 / 2;
		var centerY = 2732 / 2;
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var dx = centerX - enemy.x;
			var dy = centerY - enemy.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > 0) {
				// Pull enemies towards center
				enemy.x += dx / distance * 15;
				enemy.y += dy / distance * 15;
			}
			// Damage enemies near center
			if (distance < 200) {
				var enemyDied = enemy.takeDamage(400);
				if (enemyDied) {
					LK.setScore(LK.getScore() + 25);
					scoreTxt.setText('Score: ' + LK.getScore());
					enemy.destroy();
					enemies.splice(i, 1);
				}
			}
		}
		LK.effects.flashScreen(0x000066, 200);
		createBloodSplatter(centerX, centerY, 50);
	}
	// Handle infinity mode - omnipotent destruction
	if (hero.infinityMode && LK.ticks % 60 === 0) {
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var enemyDied = enemy.takeDamage(500);
			if (enemyDied) {
				LK.setScore(LK.getScore() + 30);
				scoreTxt.setText('Score: ' + LK.getScore());
				enemy.destroy();
				enemies.splice(i, 1);
			}
			LK.effects.flashObject(enemy, 0xffffff, 400);
		}
		LK.effects.flashScreen(0xffffff, 150);
		createBloodSplatter(hero.x, hero.y, 60);
	}
	// Handle omega destruction - ultimate annihilation
	if (hero.omegaDestructionMode && LK.ticks % 90 === 0) {
		// Instantly kill all enemies on screen
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			LK.setScore(LK.getScore() + 50);
			createBloodSplatter(enemy.x, enemy.y, 5);
			enemy.destroy();
			enemies.splice(i, 1);
		}
		LK.effects.flashScreen(0xff0000, 100);
		// Reduce blood rain to prevent crashes
		for (var i = 0; i < 5; i++) {
			createBloodSplatter(Math.random() * 2048, Math.random() * 2732, 3);
		}
	}
	// Handle wind event duration
	if (windEventActive) {
		windEventDuration -= 16.67;
		if (windEventDuration <= 0) {
			windEventActive = false;
		}
		// Create wind effects during event
		if (LK.ticks % 120 === 0) {
			// Push all enemies in swirling pattern
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				if (enemy.type !== 'windBoss') {
					var windAngle = LK.ticks * 0.05;
					enemy.x += Math.cos(windAngle) * 30;
					enemy.y += Math.sin(windAngle) * 30;
					// Keep enemies in bounds
					enemy.x = Math.max(0, Math.min(2048, enemy.x));
					enemy.y = Math.max(0, Math.min(2732, enemy.y));
				}
			}
		}
	}
	// Handle magma event duration
	if (magmaEventActive) {
		magmaEventDuration -= 16.67;
		if (magmaEventDuration <= 0) {
			magmaEventActive = false;
			// Restore normal music
			LK.playMusic('farm_war');
		}
		// Create magma effects during event - much more reduced frequency and intensity
		if (LK.ticks % 1200 === 0) {
			// Create only 1 lava burst to prevent crashes
			var lavaX = Math.random() * 2048;
			var lavaY = Math.random() * 2732;
			createBloodSplatter(lavaX, lavaY, 3);
			LK.effects.flashScreen(0xff4500, 50);
		}
	}
};
var bossSpawned = false;
var timeSlowFactor = 1.0;
var timeStopActive = false;
var gamePaused = false;
// Revival system variables
var revivalButton = null;
var revivalButtonText = null;
var evilErdo = null;
var evilErdoBattleActive = false;
// Show revival button function
function showRevivalButton() {
	if (revivalButton) return; // Button already exists
	// Create revival button
	revivalButton = LK.getAsset('menuButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x00ff00,
		width: 300,
		height: 80
	});
	revivalButton.x = 2048 / 2;
	revivalButton.y = 2732 / 2 + 100;
	revivalButton.visible = true;
	game.addChild(revivalButton);
	// Create revival button text
	revivalButtonText = new Text2('REVIVE WITH ERDO', {
		size: 40,
		fill: 0xffffff
	});
	revivalButtonText.anchor.set(0.5, 0.5);
	revivalButtonText.x = 2048 / 2;
	revivalButtonText.y = 2732 / 2 + 100;
	revivalButtonText.visible = true;
	game.addChild(revivalButtonText);
}
// Hide revival button function
function hideRevivalButton() {
	if (revivalButton) {
		revivalButton.destroy();
		revivalButton = null;
	}
	if (revivalButtonText) {
		revivalButtonText.destroy();
		revivalButtonText = null;
	}
}
// Handle revival button click
function handleRevivalClick(x, y) {
	if (!revivalButton || gameState !== 'revivalOption') return false;
	var dx = x - revivalButton.x;
	var dy = y - revivalButton.y;
	if (Math.abs(dx) <= 150 && Math.abs(dy) <= 40) {
		// Revival clicked
		hero.health = hero.maxHealth;
		heroRevivalShots = 5;
		heroRevivalShotCooldown = 0;
		erdoRevivalAvailable = false;
		erdo.deactivate();
		erdoLastActivated = LK.ticks;
		createRevivalExplosion();
		LK.effects.flashObject(hero, 0x00ff00, 500);
		hideRevivalButton();
		gameState = 'playing';
		// Spawn evil erdo boss fight
		if (evilErdo) {
			evilErdo.activate();
		}
		return true;
	}
	return false;
}
// Wind and magma event variables
var windEventActive = false;
var windEventDuration = 0;
var magmaEventActive = false;
var magmaEventDuration = 0;
// Miracle storage system
var storedMiracles = [];
var maxStoredMiracles = 5;
// Load stored miracles from storage
function loadStoredMiracles() {
	storedMiracles = storage.storedMiracles || [];
}
// Save stored miracles to storage
function saveStoredMiracles() {
	storage.storedMiracles = storedMiracles;
}
// Add miracle to storage
function addMiracleToStorage(miracleType) {
	if (storedMiracles.length < maxStoredMiracles) {
		storedMiracles.push(miracleType);
		saveStoredMiracles();
		updateStoredMiraclesUI();
		return true;
	}
	return false;
}
// Use stored miracle
function useStoredMiracle(index) {
	if (index >= 0 && index < storedMiracles.length) {
		var miracleType = storedMiracles[index];
		activateMiraclePower(miracleType, true); // Pass true to indicate from storage
		storedMiracles.splice(index, 1);
		saveStoredMiracles();
		updateStoredMiraclesUI();
		return true;
	}
	return false;
}
// Activate miracle power by type
function activateMiraclePower(type, fromStorage) {
	var isFromStorage = fromStorage || false;
	var durationMultiplier = isFromStorage ? 2.5 : 1.0; // 2.5x duration when used from storage
	if (type === 'speed') {
		hero.activateSpeedBoost();
		if (isFromStorage) {
			// Extended speed boost duration
			LK.setTimeout(function () {
				hero.speed = hero.normalSpeed;
			}, 7500); // 7.5 seconds instead of 3
		}
	} else if (type === 'shield') {
		hero.activateShield();
		if (isFromStorage) {
			hero.shieldDuration = 12500; // 12.5 seconds instead of 5
		}
	} else if (type === 'rapidFire') {
		hero.activateRapidFire();
		if (isFromStorage) {
			hero.rapidFireDuration = 10000; // 10 seconds instead of 4
		}
	} else if (type === 'freeze') {
		hero.activateFreeze();
	} else if (type === 'explosion') {
		hero.activateExplosion();
	} else if (type === 'healing') {
		hero.activateHealing();
		if (isFromStorage) {
			// Enhanced healing when used from storage
			hero.health = Math.min(hero.health + 20, hero.maxHealth);
		}
	} else if (type === 'hypercharge') {
		hero.activateHypercharge();
		if (isFromStorage) {
			hero.hyperhargeDuration = 20000; // 20 seconds instead of 8
		}
	} else if (type === 'teleport') {
		hero.activateTeleport();
	} else if (type === 'invisibility') {
		hero.activateInvisibility();
		if (isFromStorage) {
			hero.invisibilityDuration = 12500; // 12.5 seconds instead of 5
		}
	} else if (type === 'multiShot') {
		hero.activateMultiShot();
		if (isFromStorage) {
			hero.multiShotDuration = 15000; // 15 seconds instead of 6
		}
	} else if (type === 'timeSlow') {
		hero.activateTimeSlow();
		if (isFromStorage) {
			hero.timeSlowDuration = 20000; // 20 seconds instead of 8
		}
	} else if (type === 'timeStop') {
		hero.activateTimeStop();
		if (isFromStorage) {
			hero.timeStopDuration = 7500; // 7.5 seconds instead of 3
		}
	} else if (type === 'timeRewind') {
		hero.activateTimeRewind();
		if (isFromStorage) {
			hero.timeRewindDuration = 12500; // 12.5 seconds instead of 5
		}
	} else if (type === 'lifeSteal') {
		hero.activateLifeSteal();
		if (isFromStorage) {
			hero.lifeStealDuration = 25000; // 25 seconds instead of 10
		}
	} else if (type === 'berserker') {
		hero.activateBerserker();
		if (isFromStorage) {
			hero.berserkerDuration = 20000; // 20 seconds instead of 8
		}
	} else if (type === 'magnet') {
		hero.activateMagnet();
		if (isFromStorage) {
			hero.magnetDuration = 30000; // 30 seconds instead of 12
		}
	} else if (type === 'reflect') {
		hero.activateReflect();
		if (isFromStorage) {
			hero.reflectDuration = 15000; // 15 seconds instead of 6
		}
	} else if (type === 'phoenix') {
		hero.activatePhoenix();
		if (isFromStorage) {
			hero.phoenixDuration = 37500; // 37.5 seconds instead of 15
		}
	} else if (type === 'vampire') {
		hero.activateVampire();
		if (isFromStorage) {
			hero.vampireDuration = 25000; // 25 seconds instead of 10
		}
	} else if (type === 'godMode') {
		hero.activateGodMode();
		if (isFromStorage) {
			hero.godModeDuration = 5000; // 5 seconds instead of 2
		}
	} else if (type === 'shadowStrike') {
		hero.activateShadowStrike();
		if (isFromStorage) {
			hero.shadowStrikeDuration = 20000; // 20 seconds instead of 8
		}
	} else if (type === 'necromancy') {
		hero.activateNecromancy();
		if (isFromStorage) {
			hero.necromancyDuration = 30000; // 30 seconds instead of 12
		}
	} else if (type === 'aura') {
		hero.activateAura();
		if (isFromStorage) {
			hero.auraDuration = 25000; // 25 seconds instead of 10
		}
	} else if (type === 'chainLightning') {
		hero.activateChainLightning();
		if (isFromStorage) {
			hero.chainLightningDuration = 15000; // 15 seconds instead of 6
		}
	} else if (type === 'summon') {
		hero.activateSummon();
		if (isFromStorage) {
			hero.summonDuration = 37500; // 37.5 seconds instead of 15
		}
	} else if (type === 'meteor') {
		hero.activateMeteor();
		if (isFromStorage) {
			hero.meteorDuration = 20000; // 20 seconds instead of 8
		}
	} else if (type === 'berserkAura') {
		hero.activateBerserkAura();
		if (isFromStorage) {
			hero.berserkAuraDuration = 25000; // 25 seconds instead of 10
		}
	} else if (type === 'dimensionRift') {
		hero.activateDimensionRift();
		if (isFromStorage) {
			hero.dimensionRiftDuration = 17500; // 17.5 seconds instead of 7
		}
	} else if (type === 'divineBlast') {
		hero.activateDivineBlast();
		if (isFromStorage) {
			hero.divineBlastDuration = 12500; // 12.5 seconds instead of 5
		}
	} else if (type === 'divineBlast') {
		hero.activateDivineBlast();
	} else if (type === 'apocalypse') {
		hero.activateApocalypse();
		if (isFromStorage) {
			hero.apocalypseDuration = 15000; // 15 seconds instead of 6
		}
	} else if (type === 'titanShield') {
		hero.activateTitanShield();
		if (isFromStorage) {
			hero.titanShieldDuration = 30000; // 30 seconds instead of 12
		}
	} else if (type === 'berserkRage') {
		hero.activateBerserkRage();
		if (isFromStorage) {
			hero.berserkRageDuration = 20000; // 20 seconds instead of 8
		}
	} else if (type === 'lightningStorm') {
		hero.activateLightningStorm();
		if (isFromStorage) {
			hero.lightningStormDuration = 25000; // 25 seconds instead of 10
		}
	} else if (type === 'bloodRain') {
		hero.activateBloodRain();
		if (isFromStorage) {
			hero.bloodRainDuration = 37500; // 37.5 seconds instead of 15
		}
	} else if (type === 'ultioptimega') {
		var ultraAbilities = ['voidWalker', 'cosmicRage', 'soulHarvest', 'timeDistortion', 'elementalFury', 'quantumLeap', 'dragonBreath', 'arcaneStorm', 'plasmaBurst', 'galaxyCollapse', 'infinity', 'omegaDestruction'];
		var selectedAbility = ultraAbilities[Math.floor(Math.random() * ultraAbilities.length)];
		if (selectedAbility === 'voidWalker') {
			hero.activateVoidWalker();
			if (isFromStorage) hero.voidWalkerDuration = 50000; // 50 seconds instead of 20
		} else if (selectedAbility === 'cosmicRage') {
			hero.activateCosmicRage();
			if (isFromStorage) hero.cosmicRageDuration = 45000; // 45 seconds instead of 18
		} else if (selectedAbility === 'soulHarvest') {
			hero.activateSoulHarvest();
			if (isFromStorage) hero.soulHarvestDuration = 62500; // 62.5 seconds instead of 25
		} else if (selectedAbility === 'timeDistortion') {
			hero.activateTimeDistortion();
			if (isFromStorage) hero.timeDistortionDuration = 37500; // 37.5 seconds instead of 15
		} else if (selectedAbility === 'elementalFury') {
			hero.activateElementalFury();
			if (isFromStorage) hero.elementalFuryDuration = 55000; // 55 seconds instead of 22
		} else if (selectedAbility === 'quantumLeap') {
			hero.activateQuantumLeap();
			if (isFromStorage) hero.quantumLeapDuration = 50000; // 50 seconds instead of 20
		} else if (selectedAbility === 'dragonBreath') {
			hero.activateDragonBreath();
			if (isFromStorage) hero.dragonBreathDuration = 40000; // 40 seconds instead of 16
		} else if (selectedAbility === 'arcaneStorm') {
			hero.activateArcaneStorm();
			if (isFromStorage) hero.arcaneStormDuration = 60000; // 60 seconds instead of 24
		} else if (selectedAbility === 'plasmaBurst') {
			hero.activatePlasmaBurst();
			if (isFromStorage) hero.plasmaBurstDuration = 35000; // 35 seconds instead of 14
		} else if (selectedAbility === 'galaxyCollapse') {
			hero.activateGalaxyCollapse();
			if (isFromStorage) hero.galaxyCollapseDuration = 30000; // 30 seconds instead of 12
		} else if (selectedAbility === 'infinity') {
			hero.activateInfinity();
			if (isFromStorage) hero.infinityDuration = 25000; // 25 seconds instead of 10
		} else if (selectedAbility === 'omegaDestruction') {
			hero.activateOmegaDestruction();
			if (isFromStorage) hero.omegaDestructionDuration = 20000; // 20 seconds instead of 8
		}
		LK.effects.flashScreen(0x9900ff, 1000);
	}
	// Enhanced visual effect when used from storage
	if (isFromStorage) {
		LK.effects.flashScreen(0x00ff00, 500);
		LK.effects.flashObject(hero, 0x00ff00, 800);
	}
}
// Storage UI elements
var storedMiraclesUI = [];
var storageText = null;
// Update stored miracles UI
function updateStoredMiraclesUI() {
	// Initialize storedMiraclesUI if undefined
	if (!storedMiraclesUI) {
		storedMiraclesUI = [];
	}
	// Clear existing UI
	for (var i = 0; i < storedMiraclesUI.length; i++) {
		if (storedMiraclesUI[i]) {
			storedMiraclesUI[i].destroy();
		}
	}
	storedMiraclesUI = [];
	if (storageText) {
		storageText.destroy();
	}
	// Create storage title
	storageText = new Text2('STORED MIRACLES (' + storedMiracles.length + '/' + maxStoredMiracles + ')', {
		size: 35,
		fill: 0xFFD700
	});
	storageText.anchor.set(0, 0);
	LK.gui.topLeft.addChild(storageText);
	storageText.x = 20;
	storageText.y = 140;
	// Create stored miracle icons
	for (var i = 0; i < storedMiracles.length; i++) {
		var miracleType = storedMiracles[i];
		var miracleIcon = createMiracleIcon(miracleType);
		miracleIcon.x = 20 + i * 60;
		miracleIcon.y = 180;
		miracleIcon.storageIndex = i;
		LK.gui.topLeft.addChild(miracleIcon);
		storedMiraclesUI.push(miracleIcon);
	}
}
// Create miracle icon for storage UI
function createMiracleIcon(type) {
	var icon;
	if (type === 'freeze') {
		icon = LK.getAsset('freezeToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'explosion') {
		icon = LK.getAsset('explosionToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'healing') {
		icon = LK.getAsset('healingToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'hypercharge') {
		icon = LK.getAsset('hyperchargeToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'teleport') {
		icon = LK.getAsset('teleportToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'invisibility') {
		icon = LK.getAsset('invisibilityToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'multiShot') {
		icon = LK.getAsset('multiShotToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'timeSlow') {
		icon = LK.getAsset('timeSlowToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'timeStop') {
		icon = LK.getAsset('timeStopToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'timeRewind') {
		icon = LK.getAsset('timeRewindToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'lifeSteal') {
		icon = LK.getAsset('lifeStealToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'berserker') {
		icon = LK.getAsset('berserkerToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'magnet') {
		icon = LK.getAsset('magnetToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'reflect') {
		icon = LK.getAsset('reflectToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'phoenix') {
		icon = LK.getAsset('phoenixToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'vampire') {
		icon = LK.getAsset('vampireToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'godMode') {
		icon = LK.getAsset('godModeToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else if (type === 'ultioptimega') {
		icon = LK.getAsset('ultioptimegaToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	} else {
		icon = LK.getAsset('miracleToken', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.7,
			scaleY: 0.7
		});
	}
	return icon;
}
// Handle storage UI clicks
function handleStorageClick(x, y) {
	if (gameState !== 'playing' || gamePaused) return false;
	// Check if hero is in base safe zone
	var heroInSafeZone = heroBase.isHeroInSafeZone(hero.x, hero.y);
	if (!heroInSafeZone) {
		return false; // Can only use stored miracles when in base
	}
	for (var i = 0; i < storedMiraclesUI.length; i++) {
		var icon = storedMiraclesUI[i];
		if (icon && icon.storageIndex !== undefined) {
			var iconGlobalPos = LK.gui.topLeft.toGlobal(icon.position);
			var dx = x - iconGlobalPos.x;
			var dy = y - iconGlobalPos.y;
			if (Math.abs(dx) <= 25 && Math.abs(dy) <= 25) {
				useStoredMiracle(icon.storageIndex);
				return true;
			}
		}
	}
	return false;
}
// UI elements
var healthBar;

===================================================================
--- original.js
+++ change.js
@@ -2471,8 +2471,30 @@
 			buttonText.y = startY + i * 100;
 			self.addChild(buttonText);
 			self.buttonTexts.push(buttonText);
 		}
+		// Add activate all button
+		var activateAllButton = LK.getAsset('menuButton', {
+			anchorX: 0.5,
+			anchorY: 0.5,
+			tint: 0xff6600,
+			width: 450,
+			height: 80
+		});
+		activateAllButton.x = 0;
+		activateAllButton.y = startY + storedMiracles.length * 100 + 50;
+		activateAllButton.actionType = 'activateAll';
+		self.addChild(activateAllButton);
+		self.buttons.push(activateAllButton);
+		var activateAllText = new Text2('ACTIVATE ALL', {
+			size: 40,
+			fill: 0xffffff
+		});
+		activateAllText.anchor.set(0.5, 0.5);
+		activateAllText.x = 0;
+		activateAllText.y = startY + storedMiracles.length * 100 + 50;
+		self.addChild(activateAllText);
+		self.buttonTexts.push(activateAllText);
 		// Add movement freedom button
 		var movementButton = LK.getAsset('menuButton', {
 			anchorX: 0.5,
 			anchorY: 0.5,
@@ -2480,9 +2502,9 @@
 			width: 400,
 			height: 80
 		});
 		movementButton.x = 0;
-		movementButton.y = startY + storedMiracles.length * 100 + 50;
+		movementButton.y = startY + storedMiracles.length * 100 + 100;
 		movementButton.actionType = 'freeMovement';
 		self.addChild(movementButton);
 		self.buttons.push(movementButton);
 		var movementText = new Text2('FREE MOVEMENT', {
@@ -2490,9 +2512,9 @@
 			fill: 0xffffff
 		});
 		movementText.anchor.set(0.5, 0.5);
 		movementText.x = 0;
-		movementText.y = startY + storedMiracles.length * 100 + 50;
+		movementText.y = startY + storedMiracles.length * 100 + 100;
 		self.addChild(movementText);
 		self.buttonTexts.push(movementText);
 		// Add close button
 		var closeButton = LK.getAsset('menuButton', {
@@ -2502,9 +2524,9 @@
 			width: 200,
 			height: 60
 		});
 		closeButton.x = 0;
-		closeButton.y = startY + storedMiracles.length * 100 + 150;
+		closeButton.y = startY + storedMiracles.length * 100 + 200;
 		closeButton.actionType = 'close';
 		self.addChild(closeButton);
 		self.buttons.push(closeButton);
 		var closeText = new Text2('CLOSE', {
@@ -2512,9 +2534,9 @@
 			fill: 0xffffff
 		});
 		closeText.anchor.set(0.5, 0.5);
 		closeText.x = 0;
-		closeText.y = startY + storedMiracles.length * 100 + 150;
+		closeText.y = startY + storedMiracles.length * 100 + 200;
 		self.addChild(closeText);
 		self.buttonTexts.push(closeText);
 	};
 	self.show = function () {
@@ -2522,9 +2544,9 @@
 		self.visible = true;
 		self.alpha = 0;
 		self.scaleX = 0.8;
 		self.scaleY = 0.8;
-		gamePaused = true;
+		// Remove gamePaused = true to keep enemies spawning
 		self.createMiracleButtons();
 		tween(self, {
 			alpha: 1,
 			scaleX: 1,
@@ -2534,9 +2556,9 @@
 		});
 	};
 	self.hide = function () {
 		self.isVisible = false;
-		gamePaused = false;
+		// Remove gamePaused = false since game is not paused
 		tween(self, {
 			alpha: 0,
 			scaleX: 0.8,
 			scaleY: 0.8
@@ -2555,20 +2577,58 @@
 		for (var i = 0; i < self.buttons.length; i++) {
 			var button = self.buttons[i];
 			var dx = localX - button.x;
 			var dy = localY - button.y;
-			var buttonWidth = button.actionType === 'close' ? 100 : button.actionType === 'freeMovement' ? 200 : 300;
+			var buttonWidth = button.actionType === 'close' ? 100 : button.actionType === 'freeMovement' ? 200 : button.actionType === 'activateAll' ? 225 : 300;
 			var buttonHeight = button.actionType === 'close' ? 30 : 40;
 			if (Math.abs(dx) <= buttonWidth && Math.abs(dy) <= buttonHeight) {
 				if (button.actionType === 'close') {
 					self.hide();
 				} else if (button.actionType === 'freeMovement') {
 					self.hide();
-					// Movement is already free after closing menu
+					// Teleport hero away from base
+					var teleportX = Math.random() * (2048 - 200) + 100;
+					var teleportY = Math.random() * (2732 - 400) + 200;
+					// Ensure not too close to base
+					while (Math.sqrt((teleportX - heroBase.x) * (teleportX - heroBase.x) + (teleportY - heroBase.y) * (teleportY - heroBase.y)) < 300) {
+						teleportX = Math.random() * (2048 - 200) + 100;
+						teleportY = Math.random() * (2732 - 400) + 200;
+					}
+					hero.x = teleportX;
+					hero.y = teleportY;
+					LK.getSound('teleport').play();
+				} else if (button.actionType === 'activateAll') {
+					// Activate all stored miracles
+					for (var j = storedMiracles.length - 1; j >= 0; j--) {
+						useStoredMiracle(j);
+					}
+					self.hide();
+					// Teleport hero away from base
+					var teleportX = Math.random() * (2048 - 200) + 100;
+					var teleportY = Math.random() * (2732 - 400) + 200;
+					// Ensure not too close to base
+					while (Math.sqrt((teleportX - heroBase.x) * (teleportX - heroBase.x) + (teleportY - heroBase.y) * (teleportY - heroBase.y)) < 300) {
+						teleportX = Math.random() * (2048 - 200) + 100;
+						teleportY = Math.random() * (2732 - 400) + 200;
+					}
+					hero.x = teleportX;
+					hero.y = teleportY;
+					LK.getSound('teleport').play();
 				} else if (button.miracleType) {
 					// Use stored miracle
 					useStoredMiracle(button.miracleIndex);
 					self.hide();
+					// Teleport hero away from base
+					var teleportX = Math.random() * (2048 - 200) + 100;
+					var teleportY = Math.random() * (2732 - 400) + 200;
+					// Ensure not too close to base
+					while (Math.sqrt((teleportX - heroBase.x) * (teleportX - heroBase.x) + (teleportY - heroBase.y) * (teleportY - heroBase.y)) < 300) {
+						teleportX = Math.random() * (2048 - 200) + 100;
+						teleportY = Math.random() * (2732 - 400) + 200;
+					}
+					hero.x = teleportX;
+					hero.y = teleportY;
+					LK.getSound('teleport').play();
 				}
 				break;
 			}
 		}
@@ -3561,9 +3621,9 @@
 // Play farm war music
 LK.playMusic('farm_war');
 // Main game update loop
 game.update = function () {
-	if (gameState !== 'playing' || gamePaused) return;
+	if (gameState !== 'playing') return;
 	// Update hero
 	hero.update();
 	// Update controlled animal
 	if (controlledAnimal) {