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

/**** 
* Classes
****/ 
var Dragon = Container.expand(function () {
	var self = Container.call(this);
	var dragonGraphics = self.attachAsset('dragon', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.direction = 1;
	self.speed = 3;
	self.width = dragonGraphics.width;
	self.height = dragonGraphics.height;
	self.fireballCooldown = 0;
	self.health = 100;
	self.maxHealth = 100;
	self.immunityFrames = 0;
	self.attackPattern = 'normal';
	self.patternTimer = 0;
	self.patternDuration = 600; // 10 seconds at 60 FPS
	self.enraged = false;
	self.rageThreshold = 40; // Becomes enraged at 40% health
	self.changePattern = function () {
		var patterns = ['normal', 'zigzag', 'teleport', 'charge'];
		// When enraged, more aggressive patterns
		if (self.enraged) {
			patterns = ['zigzag', 'teleport', 'charge'];
		}
		self.attackPattern = patterns[Math.floor(Math.random() * patterns.length)];
		self.patternTimer = self.patternDuration;
		// Special setup for certain patterns
		if (self.attackPattern === 'teleport') {
			self.teleportCooldown = 120; // 2 seconds before first teleport
		} else if (self.attackPattern === 'charge') {
			self.chargeCooldown = 60; // 1 second before first charge
			self.chargeDirection = Math.random() > 0.5 ? 1 : -1;
		}
	};
	self.update = function () {
		// Check for pattern change
		self.patternTimer--;
		if (self.patternTimer <= 0) {
			self.changePattern();
		}
		// Check for rage mode
		if (!self.enraged && self.health <= self.maxHealth * (self.rageThreshold / 100)) {
			self.enraged = true;
			self.changePattern();
			// Visual indication
			tween(dragonGraphics, {
				tint: 0xFF3300
			}, {
				duration: 500
			});
			// Speed boost in rage mode
			self.speed *= 1.5;
		}
		// Decrease immunity frames
		if (self.immunityFrames > 0) {
			self.immunityFrames--;
		}
		// Movement based on attack pattern
		switch (self.attackPattern) {
			case 'normal':
				// Standard side-to-side movement
				self.x += self.speed * self.direction;
				if (self.x + self.width / 2 > 2048 || self.x - self.width / 2 < 0) {
					self.direction *= -1;
				}
				break;
			case 'zigzag':
				// Zigzag movement
				self.x += self.speed * 1.2 * self.direction;
				self.y += Math.sin(LK.ticks * 0.05) * 2;
				// Keep within y bounds
				if (self.y < 150) {
					self.y = 150;
				}
				if (self.y > 350) {
					self.y = 350;
				}
				// Bounce off x edges
				if (self.x + self.width / 2 > 2048 || self.x - self.width / 2 < 0) {
					self.direction *= -1;
				}
				break;
			case 'teleport':
				// Occasional teleports
				self.teleportCooldown--;
				if (self.teleportCooldown <= 0) {
					// Teleport to a new position
					var newX = Math.random() * (2048 - self.width) + self.width / 2;
					// Flash effect
					LK.effects.flashObject(self, 0xFFFFFF, 300);
					// Apply teleport
					self.x = newX;
					// Reset cooldown (shorter when enraged)
					self.teleportCooldown = self.enraged ? 90 : 180;
				} else {
					// Regular movement between teleports
					self.x += self.speed * 0.5 * self.direction;
					if (self.x + self.width / 2 > 2048 || self.x - self.width / 2 < 0) {
						self.direction *= -1;
					}
				}
				break;
			case 'charge':
				// Occasional charges at high speed
				self.chargeCooldown--;
				if (self.chargeCooldown <= 0) {
					// Start a charge
					self.isCharging = true;
					self.chargeTimer = 60; // 1 second charge
					self.chargeCooldown = self.enraged ? 120 : 240; // longer cooldown between charges
				}
				if (self.isCharging) {
					// Fast directional charge
					self.x += self.speed * 3 * self.chargeDirection;
					self.chargeTimer--;
					// End charge if we hit an edge or timer expires
					if (self.chargeTimer <= 0 || self.x + self.width / 2 > 2048 || self.x - self.width / 2 < 0) {
						self.isCharging = false;
						self.chargeDirection *= -1;
					}
				} else {
					// Regular movement between charges
					self.x += self.speed * 0.7 * self.direction;
					if (self.x + self.width / 2 > 2048 || self.x - self.width / 2 < 0) {
						self.direction *= -1;
					}
				}
				break;
		}
		// Decrease fireball cooldown
		if (self.fireballCooldown > 0) {
			self.fireballCooldown--;
		} else if (self.enraged) {
			// In rage mode, shorter cooldown
			self.fireballCooldown = 90; // 1.5 seconds
		}
	};
	self.takeDamage = function (damage) {
		// Check immunity frames
		if (self.immunityFrames > 0) {
			return; // No damage during immunity frames
		}
		self.health -= damage;
		if (self.health < 0) {
			self.health = 0;
		}
		// Flash red when hit
		LK.effects.flashObject(self, 0xFF0000, 500);
		LK.getSound('dragonHit').play();
		// Grant brief immunity
		self.immunityFrames = 30; // Half second immunity
		// Chance to change pattern when hit
		if (Math.random() < 0.3 || self.enraged && Math.random() < 0.5) {
			self.changePattern();
		}
	};
	return self;
});
var Fireball = Container.expand(function () {
	var self = Container.call(this);
	var fireballGraphics = self.attachAsset('fireball', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speedY = 7;
	self.speedX = 0;
	self.fromDragon = true;
	self.width = fireballGraphics.width;
	self.height = fireballGraphics.height;
	self.power = 1; // Base damage multiplier
	self.lastY = 0;
	self.lastX = 0;
	self.update = function () {
		// Store last position for collision detection
		self.lastX = self.x;
		self.lastY = self.y;
		// Update position
		self.y += self.speedY;
		self.x += self.speedX;
		// Rotate fireball based on direction
		if (self.speedX !== 0 || self.speedY !== 0) {
			var angle = Math.atan2(self.speedY, self.speedX);
			fireballGraphics.rotation = angle + Math.PI / 2;
		}
		// Scale fireball based on power (visual indicator)
		if (self.power > 1) {
			var scaleFactor = 1 + (self.power - 1) * 0.3; // Max 30% larger
			fireballGraphics.scale.set(scaleFactor, scaleFactor);
		}
	};
	self.slow = function () {
		self.speedY = self.speedY * 0.5;
		self.speedX = self.speedX * 0.5;
		fireballGraphics.tint = 0x33CCFF; // Blue tint for slowed fireballs
	};
	self.bounce = function () {
		self.speedY *= -1;
		self.fromDragon = false;
		// Add some random X velocity when bouncing
		self.speedX = (Math.random() - 0.5) * 5;
		// Increase fireball power when bounced (player's attack becomes stronger)
		self.power += 0.5;
		// Change tint to indicate it's now a player fireball
		fireballGraphics.tint = 0xFF9900;
	};
	return self;
});
var HealthBar = Container.expand(function (maxHealth, color) {
	var self = Container.call(this);
	self.maxWidth = 300;
	self.maxHealth = maxHealth || 100;
	self.currentHealth = self.maxHealth;
	var barBackground = self.attachAsset('healthBar', {
		anchorX: 0,
		anchorY: 0,
		tint: 0x333333
	});
	var healthFill = self.attachAsset(color === 'dragon' ? 'dragonHealthBar' : 'healthBar', {
		anchorX: 0,
		anchorY: 0
	});
	self.updateHealth = function (health) {
		self.currentHealth = health;
		var healthPercentage = self.currentHealth / self.maxHealth;
		healthFill.width = self.maxWidth * healthPercentage;
	};
	return self;
});
var Paddle = Container.expand(function () {
	var self = Container.call(this);
	var paddleGraphics = self.attachAsset('paddle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 20;
	self.width = paddleGraphics.width;
	self.height = paddleGraphics.height;
	self.shield = null;
	self.activateShield = function () {
		if (self.shield) {
			return;
		}
		self.shield = self.attachAsset('shield', {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: 0.5
		});
		LK.setTimeout(function () {
			if (self.shield) {
				self.shield.destroy();
				self.shield = null;
			}
		}, 5000);
	};
	self.grow = function () {
		tween(paddleGraphics, {
			width: paddleGraphics.width * 1.5
		}, {
			duration: 300,
			onFinish: function onFinish() {
				self.width = paddleGraphics.width;
				LK.setTimeout(function () {
					tween(paddleGraphics, {
						width: paddleGraphics.width / 1.5
					}, {
						duration: 300,
						onFinish: function onFinish() {
							self.width = paddleGraphics.width;
						}
					});
				}, 5000);
			}
		});
	};
	return self;
});
var PowerUp = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'shield'; // Default to shield type
	var color;
	switch (self.type) {
		case 'grow':
			color = 0x00FF00; // Green
			break;
		case 'slow':
			color = 0x0000FF; // Blue
			break;
		case 'shield':
		default:
			color = 0xFFCC00; // Gold
			break;
	}
	var powerUpGraphics = self.attachAsset('powerUp', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: color
	});
	self.speedY = 2;
	self.width = powerUpGraphics.width;
	self.height = powerUpGraphics.height;
	self.update = function () {
		self.y += self.speedY;
		// Make it pulse slightly
		var scale = 1 + 0.1 * Math.sin(LK.ticks * 0.1);
		powerUpGraphics.scale.set(scale, scale);
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var paddle;
var dragon;
var fireballs = [];
var powerUps = [];
var playerHealth = 100;
var playerHealthBar;
var dragonHealthBar;
var gameOver = false;
var score = 0;
var scoreText;
var powerUpTypes = ['shield', 'grow', 'slow'];
var difficulty = 1;
var powerUpChance = 0.01; // 1% chance per frame
var difficultyIncreaseTimer;
var playerIsAlive = true;
function initGame() {
	// Add background
	var background = LK.getAsset('background', {
		anchorX: 0,
		anchorY: 0,
		width: 2048,
		height: 2732
	});
	game.addChild(background);
	// Create player paddle
	paddle = new Paddle();
	paddle.x = 2048 / 2;
	paddle.y = 2732 - 150;
	game.addChild(paddle);
	// Create dragon
	dragon = new Dragon();
	dragon.x = 2048 / 2;
	dragon.y = 200;
	game.addChild(dragon);
	// Create health bars
	playerHealthBar = new HealthBar(100);
	playerHealthBar.x = 50;
	playerHealthBar.y = 2732 - 50;
	game.addChild(playerHealthBar);
	dragonHealthBar = new HealthBar(100, 'dragon');
	dragonHealthBar.x = 2048 - 350;
	dragonHealthBar.y = 50;
	game.addChild(dragonHealthBar);
	// Create score display
	scoreText = new Text2('Score: 0', {
		size: 50,
		fill: 0xFFFFFF
	});
	scoreText.anchor.set(0.5, 0);
	LK.gui.top.addChild(scoreText);
	// Reset game variables
	fireballs = [];
	powerUps = [];
	playerHealth = 100;
	dragon.health = 100;
	gameOver = false;
	score = 0;
	LK.setScore(0);
	playerIsAlive = true;
	difficulty = 1;
	updateHealthBars();
	updateScoreDisplay();
	// Start difficulty increase timer
	difficultyIncreaseTimer = LK.setInterval(increaseDifficulty, 20000); // Every 20 seconds
	// Play background music
	LK.playMusic('gameMusic');
}
function increaseDifficulty() {
	difficulty += 0.5;
	dragon.speed = Math.min(7, 3 + (difficulty - 1));
	powerUpChance = Math.max(0.005, 0.01 - (difficulty - 1) * 0.001);
	// Additional difficulty enhancements
	if (difficulty >= 2.5 && !dragon.hasRegeneration) {
		// Add health regeneration at higher difficulties
		dragon.hasRegeneration = true;
		LK.setInterval(function () {
			if (!gameOver && dragon.health < dragon.maxHealth && dragon.health > 0) {
				// Regenerate 1 health point every 3 seconds
				dragon.health = Math.min(dragon.maxHealth, dragon.health + 1);
				updateHealthBars();
			}
		}, 3000);
	}
	// Reduce pattern switching time as difficulty increases
	dragon.patternDuration = Math.max(300, 600 - (difficulty - 1) * 100);
	// Increase dragon damage resistance at higher difficulties
	if (difficulty >= 3) {
		dragon.damageResistance = 0.3; // 30% damage reduction
	} else if (difficulty >= 2) {
		dragon.damageResistance = 0.15; // 15% damage reduction
	}
	// Lower the rage threshold as difficulty increases
	dragon.rageThreshold = Math.max(20, 40 - (difficulty - 1) * 5);
}
function updateHealthBars() {
	playerHealthBar.updateHealth(playerHealth);
	dragonHealthBar.updateHealth(dragon.health);
}
function updateScoreDisplay() {
	scoreText.setText('Score: ' + score);
}
function createFireball() {
	if (dragon.fireballCooldown <= 0 && !gameOver && playerIsAlive) {
		// Dragon attack patterns based on health and attack mode
		if (dragon.enraged) {
			// Triple fireball in rage mode
			for (var i = -1; i <= 1; i++) {
				var fireball = new Fireball();
				fireball.x = dragon.x + i * 50; // Spread horizontally
				fireball.y = dragon.y + dragon.height / 2;
				// Randomize speed slightly
				var speedMultiplier = 1.0 + (Math.random() * 0.4 - 0.2); // 0.8 to 1.2
				fireball.speedY *= speedMultiplier;
				// Add slight horizontal movement to side fireballs
				if (i !== 0) {
					fireball.speedX = i * 2;
				}
				fireballs.push(fireball);
				game.addChild(fireball);
			}
			// When in charge attack pattern, faster cooldown
			if (dragon.attackPattern === 'charge') {
				dragon.fireballCooldown = 90; // 1.5 seconds
			} else {
				dragon.fireballCooldown = 120; // 2 seconds
			}
		} else {
			// Different attack patterns based on current mode
			switch (dragon.attackPattern) {
				case 'normal':
					// Single fireball
					var fireball = new Fireball();
					fireball.x = dragon.x;
					fireball.y = dragon.y + dragon.height / 2;
					fireballs.push(fireball);
					game.addChild(fireball);
					break;
				case 'zigzag':
					// Two fireballs with slight horizontal spread
					for (var i = -1; i <= 1; i += 2) {
						var fireball = new Fireball();
						fireball.x = dragon.x + i * 40;
						fireball.y = dragon.y + dragon.height / 2;
						fireball.speedX = i * 1.5; // Add sideways movement
						fireballs.push(fireball);
						game.addChild(fireball);
					}
					break;
				case 'teleport':
					// One aimed fireball that targets near the paddle
					var fireball = new Fireball();
					fireball.x = dragon.x;
					fireball.y = dragon.y + dragon.height / 2;
					// Calculate direction toward paddle with offset
					var targetX = paddle.x + (Math.random() * 200 - 100); // Add some randomness
					var deltaX = targetX - fireball.x;
					var deltaY = paddle.y - fireball.y;
					var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
					// Normalize and set speed
					fireball.speedX = deltaX / distance * 4;
					fireball.speedY = deltaY / distance * 7;
					fireballs.push(fireball);
					game.addChild(fireball);
					break;
				case 'charge':
					// Spray of 3 fireballs with spread
					for (var i = -1; i <= 1; i++) {
						var fireball = new Fireball();
						fireball.x = dragon.x;
						fireball.y = dragon.y + dragon.height / 2;
						fireball.speedY = 7;
						fireball.speedX = i * 3; // Wide spread
						fireballs.push(fireball);
						game.addChild(fireball);
					}
					break;
			}
			// Set cooldown based on attack pattern
			if (dragon.attackPattern === 'zigzag' || dragon.attackPattern === 'charge') {
				dragon.fireballCooldown = 150; // 2.5 seconds for multi-fireball attacks
			} else {
				dragon.fireballCooldown = 120; // 2 seconds for single fireball attacks
			}
		}
	}
}
function createPowerUp() {
	if (Math.random() < powerUpChance && !gameOver && playerIsAlive) {
		var type = powerUpTypes[Math.floor(Math.random() * powerUpTypes.length)];
		var powerUp = new PowerUp(type);
		powerUp.x = Math.random() * (2048 - 100) + 50;
		powerUp.y = 0;
		powerUps.push(powerUp);
		game.addChild(powerUp);
	}
}
function handleFireballCollisions() {
	for (var i = fireballs.length - 1; i >= 0; i--) {
		var fireball = fireballs[i];
		// Check for collision with paddle
		if (fireball.fromDragon && fireball.intersects(paddle)) {
			if (paddle.shield) {
				// Shield absorbs the fireball
				fireball.destroy();
				fireballs.splice(i, 1);
				// Destroy shield after absorbing
				paddle.shield.destroy();
				paddle.shield = null;
			} else {
				// Bounce the fireball
				fireball.bounce();
				LK.getSound('hit').play();
				// Add points for successful deflection
				score += 10;
				LK.setScore(score);
				updateScoreDisplay();
			}
			continue;
		}
		// Check for collision with dragon
		if (!fireball.fromDragon && fireball.intersects(dragon)) {
			// Calculate damage based on fireball power and dragon's damage resistance
			var baseDamage = 10 * fireball.power;
			var finalDamage = baseDamage;
			// Apply damage resistance if present
			if (dragon.damageResistance) {
				finalDamage = Math.max(1, Math.floor(baseDamage * (1 - dragon.damageResistance)));
			}
			dragon.takeDamage(finalDamage);
			updateHealthBars();
			// Remove the fireball
			fireball.destroy();
			fireballs.splice(i, 1);
			// Add points for hitting the dragon (bonus for powered-up fireballs)
			var pointsEarned = Math.floor(50 * fireball.power);
			score += pointsEarned;
			LK.setScore(score);
			updateScoreDisplay();
			// Check for win condition
			if (dragon.health <= 0) {
				gameOver = true;
				playerIsAlive = false;
				LK.showYouWin();
			}
			continue;
		}
		// Check if fireball is off-screen
		if (fireball.y > 2732 + fireball.height) {
			// Player missed a fireball
			if (fireball.fromDragon) {
				playerHealth -= 10;
				updateHealthBars();
				LK.getSound('playerDamage').play();
				// Flash screen red to indicate damage
				LK.effects.flashScreen(0xFF0000, 300);
				// Check for lose condition
				if (playerHealth <= 0) {
					gameOver = true;
					playerIsAlive = false;
					LK.showGameOver();
				}
			}
			// Remove the fireball
			fireball.destroy();
			fireballs.splice(i, 1);
		} else if (fireball.y < -fireball.height) {
			// Fireball went off the top of the screen
			fireball.destroy();
			fireballs.splice(i, 1);
		} else if (fireball.x < -fireball.width || fireball.x > 2048 + fireball.width) {
			// Fireball went off the sides of the screen
			fireball.destroy();
			fireballs.splice(i, 1);
		}
	}
}
function handlePowerUpCollisions() {
	for (var i = powerUps.length - 1; i >= 0; i--) {
		var powerUp = powerUps[i];
		// Check for collision with paddle
		if (powerUp.intersects(paddle)) {
			// Apply power-up effect
			switch (powerUp.type) {
				case 'grow':
					paddle.grow();
					break;
				case 'slow':
					// Slow all current fireballs
					fireballs.forEach(function (fireball) {
						if (fireball.fromDragon) {
							fireball.slow();
						}
					});
					break;
				case 'shield':
					paddle.activateShield();
					break;
			}
			// Play power-up sound
			LK.getSound('powerUpCollect').play();
			// Remove the power-up
			powerUp.destroy();
			powerUps.splice(i, 1);
			// Add points
			score += 20;
			LK.setScore(score);
			updateScoreDisplay();
			continue;
		}
		// Check if power-up is off-screen
		if (powerUp.y > 2732 + powerUp.height) {
			powerUp.destroy();
			powerUps.splice(i, 1);
		}
	}
}
// Handle movement for paddle
var isDragging = false;
game.down = function (x, y, obj) {
	isDragging = true;
	paddle.x = x;
};
game.move = function (x, y, obj) {
	if (isDragging) {
		// Convert event coordinates to game coordinates if needed
		var targetX = x;
		// Directly set the paddle position for more responsive control
		paddle.x = targetX;
		// Keep paddle within screen bounds
		if (paddle.x < paddle.width / 2) {
			paddle.x = paddle.width / 2;
		} else if (paddle.x > 2048 - paddle.width / 2) {
			paddle.x = 2048 - paddle.width / 2;
		}
	}
};
game.up = function (x, y, obj) {
	isDragging = false;
};
// Game update loop
game.update = function () {
	if (gameOver) {
		return;
	}
	// Update dragon
	dragon.update();
	// Create new fireballs
	createFireball();
	// Create power-ups
	createPowerUp();
	// Update all fireballs
	for (var i = 0; i < fireballs.length; i++) {
		fireballs[i].update();
	}
	// Update all power-ups
	for (var i = 0; i < powerUps.length; i++) {
		powerUps[i].update();
	}
	// Check for collisions
	handleFireballCollisions();
	handlePowerUpCollisions();
};
// Initialize the game
initGame();

===================================================================
--- original.js
+++ change.js
@@ -19,28 +19,151 @@
 	self.height = dragonGraphics.height;
 	self.fireballCooldown = 0;
 	self.health = 100;
 	self.maxHealth = 100;
+	self.immunityFrames = 0;
+	self.attackPattern = 'normal';
+	self.patternTimer = 0;
+	self.patternDuration = 600; // 10 seconds at 60 FPS
+	self.enraged = false;
+	self.rageThreshold = 40; // Becomes enraged at 40% health
+	self.changePattern = function () {
+		var patterns = ['normal', 'zigzag', 'teleport', 'charge'];
+		// When enraged, more aggressive patterns
+		if (self.enraged) {
+			patterns = ['zigzag', 'teleport', 'charge'];
+		}
+		self.attackPattern = patterns[Math.floor(Math.random() * patterns.length)];
+		self.patternTimer = self.patternDuration;
+		// Special setup for certain patterns
+		if (self.attackPattern === 'teleport') {
+			self.teleportCooldown = 120; // 2 seconds before first teleport
+		} else if (self.attackPattern === 'charge') {
+			self.chargeCooldown = 60; // 1 second before first charge
+			self.chargeDirection = Math.random() > 0.5 ? 1 : -1;
+		}
+	};
 	self.update = function () {
-		// Move the dragon
-		self.x += self.speed * self.direction;
-		// Bounce off the edges
-		if (self.x + self.width / 2 > 2048 || self.x - self.width / 2 < 0) {
-			self.direction *= -1;
+		// Check for pattern change
+		self.patternTimer--;
+		if (self.patternTimer <= 0) {
+			self.changePattern();
 		}
+		// Check for rage mode
+		if (!self.enraged && self.health <= self.maxHealth * (self.rageThreshold / 100)) {
+			self.enraged = true;
+			self.changePattern();
+			// Visual indication
+			tween(dragonGraphics, {
+				tint: 0xFF3300
+			}, {
+				duration: 500
+			});
+			// Speed boost in rage mode
+			self.speed *= 1.5;
+		}
+		// Decrease immunity frames
+		if (self.immunityFrames > 0) {
+			self.immunityFrames--;
+		}
+		// Movement based on attack pattern
+		switch (self.attackPattern) {
+			case 'normal':
+				// Standard side-to-side movement
+				self.x += self.speed * self.direction;
+				if (self.x + self.width / 2 > 2048 || self.x - self.width / 2 < 0) {
+					self.direction *= -1;
+				}
+				break;
+			case 'zigzag':
+				// Zigzag movement
+				self.x += self.speed * 1.2 * self.direction;
+				self.y += Math.sin(LK.ticks * 0.05) * 2;
+				// Keep within y bounds
+				if (self.y < 150) {
+					self.y = 150;
+				}
+				if (self.y > 350) {
+					self.y = 350;
+				}
+				// Bounce off x edges
+				if (self.x + self.width / 2 > 2048 || self.x - self.width / 2 < 0) {
+					self.direction *= -1;
+				}
+				break;
+			case 'teleport':
+				// Occasional teleports
+				self.teleportCooldown--;
+				if (self.teleportCooldown <= 0) {
+					// Teleport to a new position
+					var newX = Math.random() * (2048 - self.width) + self.width / 2;
+					// Flash effect
+					LK.effects.flashObject(self, 0xFFFFFF, 300);
+					// Apply teleport
+					self.x = newX;
+					// Reset cooldown (shorter when enraged)
+					self.teleportCooldown = self.enraged ? 90 : 180;
+				} else {
+					// Regular movement between teleports
+					self.x += self.speed * 0.5 * self.direction;
+					if (self.x + self.width / 2 > 2048 || self.x - self.width / 2 < 0) {
+						self.direction *= -1;
+					}
+				}
+				break;
+			case 'charge':
+				// Occasional charges at high speed
+				self.chargeCooldown--;
+				if (self.chargeCooldown <= 0) {
+					// Start a charge
+					self.isCharging = true;
+					self.chargeTimer = 60; // 1 second charge
+					self.chargeCooldown = self.enraged ? 120 : 240; // longer cooldown between charges
+				}
+				if (self.isCharging) {
+					// Fast directional charge
+					self.x += self.speed * 3 * self.chargeDirection;
+					self.chargeTimer--;
+					// End charge if we hit an edge or timer expires
+					if (self.chargeTimer <= 0 || self.x + self.width / 2 > 2048 || self.x - self.width / 2 < 0) {
+						self.isCharging = false;
+						self.chargeDirection *= -1;
+					}
+				} else {
+					// Regular movement between charges
+					self.x += self.speed * 0.7 * self.direction;
+					if (self.x + self.width / 2 > 2048 || self.x - self.width / 2 < 0) {
+						self.direction *= -1;
+					}
+				}
+				break;
+		}
 		// Decrease fireball cooldown
 		if (self.fireballCooldown > 0) {
 			self.fireballCooldown--;
+		} else if (self.enraged) {
+			// In rage mode, shorter cooldown
+			self.fireballCooldown = 90; // 1.5 seconds
 		}
 	};
 	self.takeDamage = function (damage) {
+		// Check immunity frames
+		if (self.immunityFrames > 0) {
+			return; // No damage during immunity frames
+		}
 		self.health -= damage;
 		if (self.health < 0) {
 			self.health = 0;
 		}
 		// Flash red when hit
 		LK.effects.flashObject(self, 0xFF0000, 500);
 		LK.getSound('dragonHit').play();
+		// Grant brief immunity
+		self.immunityFrames = 30; // Half second immunity
+		// Chance to change pattern when hit
+		if (Math.random() < 0.3 || self.enraged && Math.random() < 0.5) {
+			self.changePattern();
+		}
 	};
 	return self;
 });
 var Fireball = Container.expand(function () {
@@ -53,22 +176,43 @@
 	self.speedX = 0;
 	self.fromDragon = true;
 	self.width = fireballGraphics.width;
 	self.height = fireballGraphics.height;
+	self.power = 1; // Base damage multiplier
+	self.lastY = 0;
+	self.lastX = 0;
 	self.update = function () {
+		// Store last position for collision detection
+		self.lastX = self.x;
+		self.lastY = self.y;
+		// Update position
 		self.y += self.speedY;
 		self.x += self.speedX;
-		// No fireball rotation animation
+		// Rotate fireball based on direction
+		if (self.speedX !== 0 || self.speedY !== 0) {
+			var angle = Math.atan2(self.speedY, self.speedX);
+			fireballGraphics.rotation = angle + Math.PI / 2;
+		}
+		// Scale fireball based on power (visual indicator)
+		if (self.power > 1) {
+			var scaleFactor = 1 + (self.power - 1) * 0.3; // Max 30% larger
+			fireballGraphics.scale.set(scaleFactor, scaleFactor);
+		}
 	};
 	self.slow = function () {
 		self.speedY = self.speedY * 0.5;
+		self.speedX = self.speedX * 0.5;
 		fireballGraphics.tint = 0x33CCFF; // Blue tint for slowed fireballs
 	};
 	self.bounce = function () {
 		self.speedY *= -1;
 		self.fromDragon = false;
 		// Add some random X velocity when bouncing
 		self.speedX = (Math.random() - 0.5) * 5;
+		// Increase fireball power when bounced (player's attack becomes stronger)
+		self.power += 0.5;
+		// Change tint to indicate it's now a player fireball
+		fireballGraphics.tint = 0xFF9900;
 	};
 	return self;
 });
 var HealthBar = Container.expand(function (maxHealth, color) {
@@ -252,10 +396,32 @@
 	LK.playMusic('gameMusic');
 }
 function increaseDifficulty() {
 	difficulty += 0.5;
-	dragon.speed = Math.min(6, 3 + (difficulty - 1));
+	dragon.speed = Math.min(7, 3 + (difficulty - 1));
 	powerUpChance = Math.max(0.005, 0.01 - (difficulty - 1) * 0.001);
+	// Additional difficulty enhancements
+	if (difficulty >= 2.5 && !dragon.hasRegeneration) {
+		// Add health regeneration at higher difficulties
+		dragon.hasRegeneration = true;
+		LK.setInterval(function () {
+			if (!gameOver && dragon.health < dragon.maxHealth && dragon.health > 0) {
+				// Regenerate 1 health point every 3 seconds
+				dragon.health = Math.min(dragon.maxHealth, dragon.health + 1);
+				updateHealthBars();
+			}
+		}, 3000);
+	}
+	// Reduce pattern switching time as difficulty increases
+	dragon.patternDuration = Math.max(300, 600 - (difficulty - 1) * 100);
+	// Increase dragon damage resistance at higher difficulties
+	if (difficulty >= 3) {
+		dragon.damageResistance = 0.3; // 30% damage reduction
+	} else if (difficulty >= 2) {
+		dragon.damageResistance = 0.15; // 15% damage reduction
+	}
+	// Lower the rage threshold as difficulty increases
+	dragon.rageThreshold = Math.max(20, 40 - (difficulty - 1) * 5);
 }
 function updateHealthBars() {
 	playerHealthBar.updateHealth(playerHealth);
 	dragonHealthBar.updateHealth(dragon.health);
@@ -264,15 +430,89 @@
 	scoreText.setText('Score: ' + score);
 }
 function createFireball() {
 	if (dragon.fireballCooldown <= 0 && !gameOver && playerIsAlive) {
-		var fireball = new Fireball();
-		fireball.x = dragon.x;
-		fireball.y = dragon.y + dragon.height / 2;
-		fireballs.push(fireball);
-		game.addChild(fireball);
-		// Set cooldown to 2 seconds (120 frames at 60 FPS)
-		dragon.fireballCooldown = 120;
+		// Dragon attack patterns based on health and attack mode
+		if (dragon.enraged) {
+			// Triple fireball in rage mode
+			for (var i = -1; i <= 1; i++) {
+				var fireball = new Fireball();
+				fireball.x = dragon.x + i * 50; // Spread horizontally
+				fireball.y = dragon.y + dragon.height / 2;
+				// Randomize speed slightly
+				var speedMultiplier = 1.0 + (Math.random() * 0.4 - 0.2); // 0.8 to 1.2
+				fireball.speedY *= speedMultiplier;
+				// Add slight horizontal movement to side fireballs
+				if (i !== 0) {
+					fireball.speedX = i * 2;
+				}
+				fireballs.push(fireball);
+				game.addChild(fireball);
+			}
+			// When in charge attack pattern, faster cooldown
+			if (dragon.attackPattern === 'charge') {
+				dragon.fireballCooldown = 90; // 1.5 seconds
+			} else {
+				dragon.fireballCooldown = 120; // 2 seconds
+			}
+		} else {
+			// Different attack patterns based on current mode
+			switch (dragon.attackPattern) {
+				case 'normal':
+					// Single fireball
+					var fireball = new Fireball();
+					fireball.x = dragon.x;
+					fireball.y = dragon.y + dragon.height / 2;
+					fireballs.push(fireball);
+					game.addChild(fireball);
+					break;
+				case 'zigzag':
+					// Two fireballs with slight horizontal spread
+					for (var i = -1; i <= 1; i += 2) {
+						var fireball = new Fireball();
+						fireball.x = dragon.x + i * 40;
+						fireball.y = dragon.y + dragon.height / 2;
+						fireball.speedX = i * 1.5; // Add sideways movement
+						fireballs.push(fireball);
+						game.addChild(fireball);
+					}
+					break;
+				case 'teleport':
+					// One aimed fireball that targets near the paddle
+					var fireball = new Fireball();
+					fireball.x = dragon.x;
+					fireball.y = dragon.y + dragon.height / 2;
+					// Calculate direction toward paddle with offset
+					var targetX = paddle.x + (Math.random() * 200 - 100); // Add some randomness
+					var deltaX = targetX - fireball.x;
+					var deltaY = paddle.y - fireball.y;
+					var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+					// Normalize and set speed
+					fireball.speedX = deltaX / distance * 4;
+					fireball.speedY = deltaY / distance * 7;
+					fireballs.push(fireball);
+					game.addChild(fireball);
+					break;
+				case 'charge':
+					// Spray of 3 fireballs with spread
+					for (var i = -1; i <= 1; i++) {
+						var fireball = new Fireball();
+						fireball.x = dragon.x;
+						fireball.y = dragon.y + dragon.height / 2;
+						fireball.speedY = 7;
+						fireball.speedX = i * 3; // Wide spread
+						fireballs.push(fireball);
+						game.addChild(fireball);
+					}
+					break;
+			}
+			// Set cooldown based on attack pattern
+			if (dragon.attackPattern === 'zigzag' || dragon.attackPattern === 'charge') {
+				dragon.fireballCooldown = 150; // 2.5 seconds for multi-fireball attacks
+			} else {
+				dragon.fireballCooldown = 120; // 2 seconds for single fireball attacks
+			}
+		}
 	}
 }
 function createPowerUp() {
 	if (Math.random() < powerUpChance && !gameOver && playerIsAlive) {
@@ -308,15 +548,23 @@
 			continue;
 		}
 		// Check for collision with dragon
 		if (!fireball.fromDragon && fireball.intersects(dragon)) {
-			dragon.takeDamage(10);
+			// Calculate damage based on fireball power and dragon's damage resistance
+			var baseDamage = 10 * fireball.power;
+			var finalDamage = baseDamage;
+			// Apply damage resistance if present
+			if (dragon.damageResistance) {
+				finalDamage = Math.max(1, Math.floor(baseDamage * (1 - dragon.damageResistance)));
+			}
+			dragon.takeDamage(finalDamage);
 			updateHealthBars();
 			// Remove the fireball
 			fireball.destroy();
 			fireballs.splice(i, 1);
-			// Add points for hitting the dragon
-			score += 50;
+			// Add points for hitting the dragon (bonus for powered-up fireballs)
+			var pointsEarned = Math.floor(50 * fireball.power);
+			score += pointsEarned;
 			LK.setScore(score);
 			updateScoreDisplay();
 			// Check for win condition
 			if (dragon.health <= 0) {
@@ -405,16 +653,16 @@
 game.move = function (x, y, obj) {
 	if (isDragging) {
 		// Convert event coordinates to game coordinates if needed
 		var targetX = x;
-		// Apply bounds to target position
-		if (targetX < paddle.width / 2) {
-			targetX = paddle.width / 2;
-		} else if (targetX > 2048 - paddle.width / 2) {
-			targetX = 2048 - paddle.width / 2;
-		}
-		// Use direct movement for better control
+		// Directly set the paddle position for more responsive control
 		paddle.x = targetX;
+		// Keep paddle within screen bounds
+		if (paddle.x < paddle.width / 2) {
+			paddle.x = paddle.width / 2;
+		} else if (paddle.x > 2048 - paddle.width / 2) {
+			paddle.x = 2048 - paddle.width / 2;
+		}
 	}
 };
 game.up = function (x, y, obj) {
 	isDragging = false;