/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.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 BaseMenu = 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.animalTypes = ['sheep', 'cow', 'chicken', 'pig', 'goat', 'duck'];
	self.createButtons = function () {
		var startY = -200;
		var buttonWidth = 300;
		var buttonHeight = 80;
		// Add title
		var titleText = new Text2('SELECT ANIMAL TO CONTROL', {
			size: 80,
			fill: 0xffff00
		});
		titleText.anchor.set(0.5, 0.5);
		titleText.x = 0;
		titleText.y = -400;
		self.addChild(titleText);
		for (var i = 0; i < self.animalTypes.length; i++) {
			var button = LK.getAsset('menuButton', {
				anchorX: 0.5,
				anchorY: 0.5,
				tint: 0x666666,
				width: buttonWidth,
				height: buttonHeight
			});
			button.x = 0;
			button.y = startY + i * 100;
			button.animalType = self.animalTypes[i];
			self.addChild(button);
			self.buttons.push(button);
			var buttonText = new Text2(self.animalTypes[i].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 close button
		var closeButton = LK.getAsset('menuButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			tint: 0xff4444,
			width: 200,
			height: 60
		});
		closeButton.x = 0;
		closeButton.y = 350;
		closeButton.animalType = '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 = 350;
		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;
		gamePaused = true;
		tween(self, {
			alpha: 1,
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 300
		});
	};
	self.hide = function () {
		self.isVisible = false;
		gamePaused = false;
		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.animalType === 'close' ? 100 : 150;
			var buttonHeight = button.animalType === 'close' ? 30 : 40;
			if (Math.abs(dx) <= buttonWidth && Math.abs(dy) <= buttonHeight) {
				if (button.animalType === 'close') {
					self.hide();
				} else {
					controlledAnimalType = button.animalType;
					controlledAnimalDuration = 60000; // 1 minute
					self.hide();
				}
				break;
			}
		}
	};
	self.alpha = 0;
	self.scaleX = 0.8;
	self.scaleY = 0.8;
	self.createButtons();
	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 = 500;
	self.range = 300;
	self.damage = 20;
	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.2;
	trailGraphics.scaleY = 0.6;
	self.life = 180; // 3 seconds at 60fps
	self.maxLife = 180;
	self.fadeSpeed = 0.005;
	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 = 8;
	self.damage = 25;
	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.8;
		self.damage = 18;
		self.health = 55;
		self.maxHealth = 55;
	} 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 = 2.5;
		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 = 45;
		self.health = 150;
		self.maxHealth = 150;
		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 = 65;
		self.health = 200;
		self.maxHealth = 200;
		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 = 3.5;
		self.damage = 60;
		self.health = 800;
		self.maxHealth = 800;
		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 = 4.2;
		self.damage = 80;
		self.health = 350;
		self.maxHealth = 350;
		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.8;
		self.damage = 100;
		self.health = 450;
		self.maxHealth = 450;
		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 = 5.0;
		self.damage = 70;
		self.health = 300;
		self.maxHealth = 300;
		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 = 4.5;
		self.damage = 90;
		self.health = 380;
		self.maxHealth = 380;
		self.omegaTimer = 0;
		self.isOmega = true;
	}
	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.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 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 = 8;
	self.damage = 40; // Higher 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 = 120;
		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);
				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 = 4;
	self.normalSpeed = 4;
	self.boostedSpeed = 8;
	self.hasShield = false;
	self.shieldDuration = 0;
	self.rapidFire = false;
	self.rapidFireDuration = 0;
	self.lastShot = 0;
	self.shootCooldown = 300; // milliseconds
	self.normalShootCooldown = 300;
	self.rapidShootCooldown = 100;
	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.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.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
				});
			}
		}
	};
	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 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 {
			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 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
****/ 
// Game state variables
// Hero character
// Farm animal enemies
// Projectiles and power-ups
// UI elements
// Sound effects
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 baseMenu;
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
	healthBarBg = LK.getAsset('healthBar', {
		anchorX: 0,
		anchorY: 0,
		tint: 0x444444,
		width: 220,
		height: 25
	});
	// Health bar
	healthBar = LK.getAsset('healthBar', {
		anchorX: 0,
		anchorY: 0,
		width: 200,
		height: 20
	});
	LK.gui.topLeft.addChild(healthBarBg);
	LK.gui.topLeft.addChild(healthBar);
	healthBarBg.x = 120;
	healthBarBg.y = 20;
	healthBar.x = 130;
	healthBar.y = 25;
	// 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() {
	var enemy;
	var rand = Math.random();
	// Check if boss should spawn at different levels - much more frequent
	var shouldSpawnBoss = false;
	var bossType = 'hyperChicken';
	// Reduce boss spawn thresholds for more frequent bosses
	var frequentBossLevels = [500, 1000, 1800, 2800, 4000, 5500, 7200, 9000, 11000, 13500];
	for (var b = 0; b < frequentBossLevels.length; b++) {
		if (LK.getScore() >= frequentBossLevels[b] && currentBossLevel <= b) {
			shouldSpawnBoss = true;
			currentBossLevel = b + 1;
			// More boss variety
			var bossTypes = ['hyperChicken', 'omegaSheep', 'omegaCow', 'omegaChicken', 'omegaPig', 'hyperCow', 'hyperSheep'];
			bossType = bossTypes[b % bossTypes.length];
			break;
		}
	}
	// Random boss spawn chance increases over time
	if (!shouldSpawnBoss && currentWave >= 3) {
		var bossChance = Math.min(0.15 + currentWave * 0.02, 0.4);
		if (Math.random() < bossChance) {
			shouldSpawnBoss = true;
			var omegaTypes = ['omegaSheep', 'omegaCow', 'omegaChicken', 'omegaPig'];
			bossType = omegaTypes[Math.floor(Math.random() * omegaTypes.length)];
		}
	}
	if (shouldSpawnBoss) {
		enemy = new Enemy(bossType);
	} 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.08) {
			enemy = new Enemy('sheep');
		} else if (rand < 0.15) {
			enemy = new Enemy('chicken');
		} else if (rand < 0.22) {
			enemy = new Enemy('cow');
		} else if (rand < 0.28) {
			enemy = new Enemy('chick');
		} else if (rand < 0.35) {
			enemy = new Enemy('snake');
		} else if (rand < 0.42) {
			enemy = new Enemy('mouse');
		} else if (rand < 0.47) {
			enemy = new Enemy('pig');
		} else if (rand < 0.52) {
			enemy = new Enemy('goat');
		} else if (rand < 0.57) {
			enemy = new Enemy('duck');
		} else if (rand < 0.62) {
			enemy = new Enemy('rabbit');
		} else if (rand < 0.70) {
			enemy = new Enemy('hyperSheep');
		} else if (rand < 0.78) {
			enemy = new Enemy('hyperCow');
		} else if (rand < 0.85) {
			enemy = new Enemy('hyperChicken');
		} else if (rand < 0.90) {
			// Add new violent animal types
			enemy = new Lion();
		} else if (rand < 0.94) {
			enemy = new Tiger();
		} else if (rand < 0.97) {
			enemy = new Wolf();
		} else if (rand < 0.99) {
			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) {
	intensity = intensity || 5;
	// Double the blood intensity for more gore
	intensity *= 2;
	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;
		// Add velocity variation for more violent splatter
		blood.velocityX = (Math.random() - 0.5) * 16;
		blood.velocityY = (Math.random() - 0.5) * 16;
		bloodParticles.push(blood);
		game.addChild(blood);
	}
	// Add screen shake for violent impact
	tween(game, {
		x: game.x + 5
	}, {
		duration: 50
	});
	tween(game, {
		x: game.x - 5
	}, {
		duration: 50
	});
	tween(game, {
		x: game.x
	}, {
		duration: 50
	});
}
// Create blood trail effect
function createBloodTrail(x, y) {
	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.08) {
		token.setTokenType('speed');
	} else if (rand < 0.16) {
		token.setTokenType('shield');
	} else if (rand < 0.24) {
		token.setTokenType('rapidFire');
	} else if (rand < 0.32) {
		token.setTokenType('freeze');
	} else if (rand < 0.40) {
		token.setTokenType('explosion');
	} else if (rand < 0.48) {
		token.setTokenType('healing');
	} else if (rand < 0.56) {
		token.setTokenType('hypercharge');
	} else if (rand < 0.64) {
		token.setTokenType('teleport');
	} else if (rand < 0.72) {
		token.setTokenType('invisibility');
	} else if (rand < 0.80) {
		token.setTokenType('multiShot');
	} else if (rand < 0.87) {
		token.setTokenType('timeSlow');
	} else if (rand < 0.94) {
		token.setTokenType('timeStop');
	} else {
		token.setTokenType('timeRewind');
	}
	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;
	}
	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 base menu
baseMenu = game.addChild(new BaseMenu());
baseMenu.x = 2048 / 2;
baseMenu.y = 2732 / 2;
// Initialize Erdo helper
erdo = game.addChild(new Erdo());
// Main game update loop
game.update = function () {
	if (gameState !== 'playing' || gamePaused) 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);
	// 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 = 200 * healthPercent;
	// 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();
	}
	// 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 = 200; // Quick succession
		}
	} else {
		// Auto shoot
		if (LK.ticks - lastAutoShoot > hero.shootCooldown / 16.67) {
			shootAtNearestEnemy();
			lastAutoShoot = LK.ticks;
		}
	}
	// Wave spawning
	if (enemiesSpawned < enemiesInWave) {
		waveSpawnTimer++;
		if (waveSpawnTimer >= 30) {
			// Spawn every 0.5 seconds - much faster
			spawnEnemy();
			// Spawn multiple enemies at once for higher waves
			if (currentWave >= 5) {
				spawnEnemy();
			}
			if (currentWave >= 10) {
				spawnEnemy();
			}
			if (currentWave >= 15) {
				spawnEnemy();
				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 hero (only if not in safe zone)
		if (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 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);
				if (enemyDied) {
					// Create miracle token chance
					if (Math.random() < 0.3) {
						// 30% 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
	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);
		}
	}
	// Update blood trails
	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);
		}
	}
	// 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);
			// Activate power-up
			if (token.type === 'speed') {
				hero.activateSpeedBoost();
			} else if (token.type === 'shield') {
				hero.activateShield();
			} else if (token.type === 'rapidFire') {
				hero.activateRapidFire();
			} else if (token.type === 'freeze') {
				hero.activateFreeze();
			} else if (token.type === 'explosion') {
				hero.activateExplosion();
			} else if (token.type === 'healing') {
				hero.activateHealing();
			} else if (token.type === 'hypercharge') {
				hero.activateHypercharge();
			} else if (token.type === 'teleport') {
				hero.activateTeleport();
			} else if (token.type === 'invisibility') {
				hero.activateInvisibility();
			} else if (token.type === 'multiShot') {
				hero.activateMultiShot();
			} else if (token.type === 'timeSlow') {
				hero.activateTimeSlow();
			} else if (token.type === 'timeStop') {
				hero.activateTimeStop();
			} else if (token.type === 'timeRewind') {
				hero.activateTimeRewind();
			}
			LK.getSound('tokenCollect').play();
			token.destroy();
			miracleTokens.splice(i, 1);
		}
	}
};
var bossSpawned = false;
var timeSlowFactor = 1.0;
var timeStopActive = false;
var gamePaused = false;
// Revival system variables
var revivalButton = null;
var revivalButtonText = null;
// 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';
		return true;
	}
	return false;
}
// UI elements
var healthBar;

===================================================================
--- original.js
+++ change.js
@@ -1073,8 +1073,21 @@
 	};
 	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
 		}, {
@@ -1126,8 +1139,62 @@
 	};
 	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 = 8;
+	self.damage = 40; // Higher 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 = 120;
+		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);
+				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,
@@ -1157,8 +1224,10 @@
 	self.timeStopMode = false;
 	self.timeStopDuration = 0;
 	self.timeRewindMode = false;
 	self.timeRewindDuration = 0;
+	self.explosiveShotMode = false;
+	self.explosiveShotDuration = 0;
 	self.savedPosition = {
 		x: 0,
 		y: 0
 	};
@@ -1341,8 +1410,20 @@
 					}
 				});
 			}
 		}
+		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
+				});
+			}
+		}
 	};
 	return self;
 });
 var HeroBase = Container.expand(function () {
@@ -1869,9 +1950,22 @@
 			nearestEnemy = enemy;
 		}
 	}
 	if (nearestEnemy) {
-		if (hero.multiShotMode) {
+		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;
@@ -2280,8 +2374,12 @@
 		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);
 				if (enemyDied) {
 					// Create miracle token chance
 					if (Math.random() < 0.3) {