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

/**** 
* Classes
****/ 
var DragonHead = Container.expand(function () {
	var self = Container.call(this);
	var head = self.attachAsset('dragonHead', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2,
		scaleY: 2
	});
	var headOpen = self.attachAsset('dragonHeadOpen', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2,
		scaleY: 2,
		alpha: 0
	});
	// Position smoothing variables
	self.targetX = 2048 / 2;
	self.targetY = 2732 * 0.2;
	self.smoothingFactor = 0.15;
	// Simplified rotation variables
	self.currentRotation = 0;
	self.targetRotation = 0;
	self.rotationSmoothing = 0.1;
	self.update = function () {
		// Position tracking
		if (facekit.noseTip) {
			self.targetX = facekit.noseTip.x;
			self.targetY = facekit.noseTip.y;
		}
		// Apply position smoothing
		self.x += (self.targetX - self.x) * self.smoothingFactor;
		self.y += (self.targetY - self.y) * self.smoothingFactor;
		// Simplified rotation calculation directly from eye positions
		if (facekit.leftEye && facekit.rightEye) {
			// Calculate angle between eyes (simpler approach)
			var dx = facekit.rightEye.x - facekit.leftEye.x;
			var dy = facekit.rightEye.y - facekit.leftEye.y;
			// Get the raw angle in radians and negate it to reverse the direction
			var rawAngle = -Math.atan2(dy, dx);
			// Limit the rotation to prevent extreme angles (±0.3 radians ≈ ±17 degrees)
			self.targetRotation = Math.max(-0.3, Math.min(0.3, rawAngle));
			// Apply rotation smoothing
			self.rotation += (self.targetRotation - self.rotation) * self.rotationSmoothing;
			// Debug output - uncomment if you have console logging
			// console.log("Eyes dx/dy:", dx, dy, "Target rotation:", self.targetRotation, "Current rotation:", self.rotation);
		}
		// Toggle dragon head assets based on mouth open state
		if (facekit && facekit.mouthOpen) {
			head.alpha = 0;
			headOpen.alpha = 1;
		} else {
			head.alpha = 1;
			headOpen.alpha = 0;
		}
	};
	return self;
});
var Enemy = Container.expand(function (type) {
	var self = Container.call(this);
	var assetId = 'enemy1';
	if (type === 2) {
		assetId = 'enemy2';
	}
	if (type === 3) {
		assetId = 'enemy3';
	}
	self.type = type || 1;
	var enemyGraphic = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Different enemy types have different speeds and health
	switch (self.type) {
		case 1:
			self.speed = 2;
			self.health = 1;
			break;
		case 2:
			self.speed = 1.5;
			self.health = 2;
			break;
		case 3:
			self.speed = 3;
			self.health = 1;
			break;
	}
	self.activate = function (type) {
		self.type = type || 1;
		self.visible = true;
		self.toDestroy = false;
		// Set type-specific properties
		switch (self.type) {
			case 1:
				self.speed = 2;
				self.health = 1;
				break;
			case 2:
				self.speed = 1.5;
				self.health = 2;
				break;
			case 3:
				self.speed = 3;
				self.health = 1;
				break;
		}
		// Set initial scale based on spawn position
		var maxDistance = 2732;
		var distancePercent = self.y / maxDistance;
		var newScale = 0.3 + distancePercent * (2.0 - 0.3);
		self.scaleX = newScale;
		self.scaleY = newScale;
	};
	self.update = function () {
		self.y -= self.speed; // Enemies move up the screen toward the player
		// Only start scaling when actually on screen
		var maxDistance = 2732; // Screen height
		var minScale = 0.3; // Smallest size
		var maxScale = 2.0; // Largest size
		// Keep full scale until enemy is actually on screen
		if (self.y <= maxDistance) {
			var distancePercent = self.y / maxDistance;
			var newScale = minScale + distancePercent * (maxScale - minScale);
			// Apply scaling
			self.scaleX = newScale;
			self.scaleY = newScale;
		} else {
			// Keep maximum scale while off-screen
			self.scaleX = maxScale;
			self.scaleY = maxScale;
		}
		// Also adjust speed based on proximity (slower as they get closer)
		var baseSpeed = self.type;
		self.speed = baseSpeed * (0.5 + (self.y <= maxDistance ? self.y / maxDistance : 1) * 0.5);
	};
	self.hit = function () {
		self.health--;
		// Visual feedback when hit
		LK.effects.flashObject(enemyGraphic, 0xff0000, 200);
		// Different death animations based on enemy type
		if (self.health <= 0) {
			if (self.type === 1) {
				// Type 1 enemy burns to ash
				tween(enemyGraphic, {
					alpha: 0,
					scaleX: 0.5,
					scaleY: 0.5
				}, {
					duration: 500,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						self.toDestroy = true;
					}
				});
			} else if (self.type === 2) {
				// Type 2 enemy spins away
				tween(enemyGraphic, {
					rotation: Math.PI * 4,
					y: self.y + 300
				}, {
					duration: 700,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						self.toDestroy = true;
					}
				});
			} else if (self.type === 3) {
				// Type 3 enemy explodes outward
				tween(enemyGraphic, {
					alpha: 0,
					scaleX: 2,
					scaleY: 2
				}, {
					duration: 300,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						self.toDestroy = true;
					}
				});
			}
			return true;
		}
		return false;
	};
	self.deactivate = function () {
		self.visible = false;
		self.toDestroy = false;
	};
	return self;
});
var FireParticle = Container.expand(function () {
	var self = Container.call(this);
	var particle = self.attachAsset('fireParticle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.visible = false;
	self.vx = Math.random() * 4 - 2;
	self.vy = Math.random() * 2 + 1;
	self.lifespan = 20 + Math.random() * 20;
	self.age = 0;
	self.update = function () {
		self.x += self.vx;
		self.y += self.vy;
		self.age++;
		particle.alpha = 1 - self.age / self.lifespan;
		if (self.age >= self.lifespan) {
			self.deactivate(); // Use deactivate instead of destroy
		}
	};
	self.activate = function (x, y) {
		self.x = x;
		self.y = y;
		self.visible = true;
		self.vx = Math.random() * 4 - 2;
		self.vy = Math.random() * 2 + 1;
		self.lifespan = 20 + Math.random() * 20;
		self.age = 0;
		particle.alpha = 1;
	};
	self.deactivate = function () {
		self.visible = false;
		// Don't modify the array here - do it in the main game loop
	};
	return self;
});
var Fireball = Container.expand(function () {
	var self = Container.call(this);
	var fireballGraphic = self.attachAsset('fireball', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 15;
	self.active = true;
	self.update = function () {
		if (!self.active) {
			return;
		}
		self.y += self.speed;
		// Create fire trail particles
		if (Math.random() < 0.3) {
			createFireParticle(self.x + (Math.random() * 40 - 20), self.y + 20);
		}
	};
	self.activate = function (x, y) {
		self.x = x;
		self.y = y;
		self.visible = true;
		self.active = true;
	};
	self.deactivate = function () {
		self.visible = false;
		self.active = false;
		// Remove array manipulation from here
	};
	return self;
});
var FlyingBackground = Container.expand(function () {
	var self = Container.call(this);
	// Create sky background (top half)
	var sky = self.attachAsset('skyBackground', {
		anchorX: 0.5,
		anchorY: 1.0,
		// Anchor to bottom
		x: 2048 / 2,
		y: 2732 / 2 // Place at middle of screen (horizon line)
	});
	// Create field background (bottom half)
	var field = self.attachAsset('fieldBackground', {
		anchorX: 0.5,
		anchorY: 0,
		// Anchor to top
		x: 2048 / 2,
		y: 2732 / 2 // Place at middle of screen (horizon line)
	});
	// Horizon line is at y = 2732/2
	self.horizonY = 2732 / 2;
	// Create clouds
	self.clouds = [];
	for (var i = 0; i < 8; i++) {
		// Start clouds with larger scale farther from horizon
		var startY = self.horizonY - 400 - Math.random() * 600;
		var distanceFromHorizon = Math.abs(startY - self.horizonY);
		var startScale = 0.5 + distanceFromHorizon / 800;
		var cloud = self.attachAsset('cloudShape', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: Math.random() * 2048,
			y: startY,
			alpha: 0.8,
			scaleX: startScale,
			scaleY: startScale * 0.8
		});
		// Store with motion properties
		self.clouds.push({
			sprite: cloud,
			speedY: 1 + Math.random() * 2,
			speedX: (Math.random() - 0.5) * 1.5,
			// Slight side-to-side drift
			targetY: self.horizonY
		});
	}
	// Create field elements
	self.fieldElements = [];
	for (var j = 0; j < 12; j++) {
		// Start field elements with larger scale farther from horizon
		var fieldStartY = self.horizonY + 400 + Math.random() * 800;
		var fieldDistanceFromHorizon = Math.abs(fieldStartY - self.horizonY);
		var fieldStartScale = 0.5 + fieldDistanceFromHorizon / 1000;
		var fieldElement = self.attachAsset('fieldElement', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: Math.random() * 2048,
			y: fieldStartY,
			scaleX: fieldStartScale,
			scaleY: fieldStartScale * 0.8
		});
		// Store with motion properties
		self.fieldElements.push({
			sprite: fieldElement,
			speedY: 2 + Math.random() * 3,
			speedX: (Math.random() - 0.5) * 3,
			// More side-to-side movement for field elements
			targetY: self.horizonY
		});
	}
	self.update = function () {
		// Update clouds
		for (var i = 0; i < self.clouds.length; i++) {
			var cloud = self.clouds[i];
			// Move cloud toward horizon
			cloud.sprite.y += cloud.speedY;
			cloud.sprite.x += cloud.speedX;
			// Calculate scale based on distance from horizon
			var distanceFactor = Math.max(0.05, (cloud.sprite.y - self.horizonY) / -500);
			cloud.sprite.scaleX = distanceFactor;
			cloud.sprite.scaleY = distanceFactor * 0.8;
			// Adjust alpha for fade effect near horizon
			cloud.sprite.alpha = Math.min(0.9, distanceFactor);
			// Reset cloud if it reaches horizon or gets too small
			if (cloud.sprite.y >= self.horizonY - 10 || cloud.sprite.scaleX < 0.1) {
				cloud.sprite.y = self.horizonY - 800 - Math.random() * 400;
				cloud.sprite.x = Math.random() * 2048;
				var newDistanceFactor = (cloud.sprite.y - self.horizonY) / -500;
				cloud.sprite.scaleX = newDistanceFactor;
				cloud.sprite.scaleY = newDistanceFactor * 0.8;
				cloud.sprite.alpha = 0.8;
			}
		}
		// Update field elements
		for (var j = 0; j < self.fieldElements.length; j++) {
			var element = self.fieldElements[j];
			// Move field element toward horizon
			element.sprite.y -= element.speedY;
			element.sprite.x += element.speedX;
			// Calculate scale based on distance from horizon
			var fieldDistanceFactor = Math.max(0.05, (element.sprite.y - self.horizonY) / 500);
			element.sprite.scaleX = fieldDistanceFactor;
			element.sprite.scaleY = fieldDistanceFactor * 0.8;
			// Adjust alpha for fade effect near horizon
			element.sprite.alpha = Math.min(0.9, fieldDistanceFactor);
			// Reset field element if it reaches horizon or goes off screen
			if (element.sprite.y <= self.horizonY + 10 || element.sprite.scaleX < 0.1 || element.sprite.x < -50 || element.sprite.x > 2048 + 50) {
				element.sprite.y = self.horizonY + 800 + Math.random() * 400;
				element.sprite.x = Math.random() * 2048;
				var newFieldDistanceFactor = (element.sprite.y - self.horizonY) / 500;
				element.sprite.scaleX = newFieldDistanceFactor;
				element.sprite.scaleY = newFieldDistanceFactor * 0.8;
				element.sprite.alpha = 0.9;
			}
		}
	};
	return self;
});
var ObjectPool = Container.expand(function (ObjectClass, size) {
	var self = Container.call(this);
	self.available = [];
	self.active = [];
	// Initialize pool
	for (var i = 0; i < size; i++) {
		var obj = new ObjectClass();
		obj.visible = false;
		self.addChild(obj);
		self.available.push(obj);
	}
	self.spawn = function (x, y, params) {
		if (self.available.length === 0) {
			return null;
		}
		var obj = self.available.pop();
		obj.activate(x, y, params);
		self.active.push(obj);
		return obj;
	};
	self.recycle = function (obj) {
		var index = self.active.indexOf(obj);
		if (index > -1) {
			self.active.splice(index, 1);
			obj.deactivate();
			self.available.push(obj);
		}
	};
	self.update = function () {
		for (var i = self.active.length - 1; i >= 0; i--) {
			var obj = self.active[i];
			obj.update();
			if (!obj.visible || obj.toDestroy) {
				self.recycle(obj);
			}
		}
	};
	return self;
});
var PowerBar = Container.expand(function () {
	var self = Container.call(this);
	// Background bar
	var background = self.attachAsset('powerBarBg', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Foreground bar (showing power level)
	var bar = self.attachAsset('powerBar', {
		anchorX: 0,
		anchorY: 0.5,
		x: -250
	});
	self.maxWidth = 500;
	self.setPower = function (percent) {
		var newWidth = self.maxWidth * percent;
		bar.width = Math.max(0, Math.min(newWidth, self.maxWidth));
		// Change color based on power level
		if (percent < 0.3) {
			bar.tint = 0xe74c3c; // Red when low
		} else if (percent < 0.6) {
			bar.tint = 0xf39c12; // Orange when medium
		} else {
			bar.tint = 0x2ecc71; // Green when high
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Set dark blue background for sky effect
game.setBackgroundColor(0x2c3e50);
// Game state variables
var score = 0;
var fireballPool = [];
var particlePool = [];
var enemyPool = [];
var POOL_SIZE_ENEMIES = 50;
var POOL_SIZE_FIREBALLS = 100;
var POOL_SIZE_PARTICLES = 400;
var firepower = 100;
var maxFirepower = 100;
var firepowerRechargeRate = 0.5;
var firepowerUseRate = 2;
var gameActive = true;
var fireballs = [];
var enemies = [];
var fireParticles = [];
var isFiring = false;
var lastFireTime = 0;
var fireRate = 150; // ms between fireballs
var enemySpawnRate = 60; // Frames between enemy spawns
var difficultyScaling = 0;
var flyingBackground = new FlyingBackground();
game.addChild(flyingBackground);
// Create dragon head (player character)
var dragon = game.addChild(new DragonHead());
dragon.x = 2048 / 2;
dragon.y = 2732 * 0.2; // Place dragon at top fifth of screen
// Create power bar
var powerBar = new PowerBar();
powerBar.x = 2048 / 2;
powerBar.y = 150;
LK.gui.top.addChild(powerBar);
// Score display
var scoreTxt = new Text2('0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
scoreTxt.y = 50;
LK.gui.top.addChild(scoreTxt);
// Create a function to add fire particles
function createFireParticle(x, y) {
	var particle = particlePool.find(function (p) {
		return !p.visible;
	});
	if (particle) {
		particle.activate(x, y);
		fireParticles.push(particle);
	}
}
function initObjectPools() {
	// Create fireball pool
	for (var i = 0; i < POOL_SIZE_FIREBALLS; i++) {
		var fireball = new Fireball();
		fireball.visible = false;
		fireball.active = false; // Add this line
		game.addChild(fireball);
		fireballPool.push(fireball);
	}
	// Create particle pool
	for (var j = 0; j < POOL_SIZE_PARTICLES; j++) {
		var particle = new FireParticle();
		particle.visible = false;
		game.addChild(particle);
		particlePool.push(particle);
	}
	for (var k = 0; k < POOL_SIZE_ENEMIES; k++) {
		var enemy = new Enemy(Math.floor(Math.random() * 3) + 1);
		enemy.visible = false;
		game.addChild(enemy);
		enemyPool.push(enemy);
	}
}
// Function to spawn a fireball
function spawnFireball() {
	if (!gameActive || firepower < 10) {
		return;
	}
	var now = Date.now();
	if (now - lastFireTime < fireRate) {
		return;
	}
	lastFireTime = now;
	// Find available fireball from pool
	var fireball = fireballPool.find(function (fb) {
		return !fb.visible;
	});
	if (fireball) {
		fireball.activate(dragon.x, dragon.y + 50);
		fireballs.push(fireball);
	}
	// Use firepower
	firepower -= firepowerUseRate;
	powerBar.setPower(firepower / maxFirepower);
	// Play sound
	LK.getSound('firebreathSound').play();
}
// Function to spawn enemies
function spawnEnemy() {
	if (!gameActive) {
		return;
	}
	var type = Math.floor(Math.random() * 3) + 1;
	var enemy = enemyPool.find(function (e) {
		return !e.visible;
	});
	if (enemy) {
		// Use the activate method instead
		enemy.activate(type);
		// Position
		enemy.x = Math.random() * (2048 - 200) + 100;
		enemy.y = 2732 + 100;
		enemies.push(enemy);
	}
}
initObjectPools();
// Game update logic
game.update = function () {
	if (!gameActive) {
		return;
	}
	// Check if mouth is open for fire breathing
	if (facekit && facekit.mouthOpen) {
		isFiring = true;
		spawnFireball();
	} else {
		isFiring = false;
	}
	// Recharge firepower when not firing
	if (!isFiring && firepower < maxFirepower) {
		firepower += firepowerRechargeRate;
		powerBar.setPower(firepower / maxFirepower);
	}
	// Warn player when power is low
	if (firepower < 20 && Math.floor(LK.ticks) % 60 === 0) {
		LK.getSound('powerLow').play();
	}
	// Spawn enemies
	if (LK.ticks % Math.max(10, enemySpawnRate - difficultyScaling) === 0) {
		spawnEnemy();
	}
	// Increase difficulty over time
	if (LK.ticks % 300 === 0 && difficultyScaling < 40) {
		difficultyScaling += 1;
	}
	// Update fireballs and check for collisions
	for (var i = fireballs.length - 1; i >= 0; i--) {
		var fireball = fireballs[i];
		// Remove fireballs that go off screen
		if (fireball.y < -100) {
			fireball.deactivate();
			fireballs.splice(i, 1); // Remove from active array here
			continue;
		}
		// Check for collisions with enemies
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			// Remove distance check and just use engine's intersection
			if (fireball.active && enemy.visible && fireball.intersects(enemy)) {
				// Hit the enemy
				var killed = enemy.hit();
				if (killed) {
					score += enemy.type * 10;
					scoreTxt.setText(score);
					LK.setScore(score);
					LK.getSound('enemyDefeat').play();
				}
				// Deactivate the fireball
				fireball.active = false;
				LK.effects.flashObject(fireball, 0xffffff, 100);
				fireball.deactivate();
				fireballs.splice(i, 1);
				break;
			}
		}
	}
	// Update enemies
	for (var k = enemies.length - 1; k >= 0; k--) {
		var currentEnemy = enemies[k];
		// Check if enemy is off screen (went too far up)
		if (currentEnemy.y < -200) {
			currentEnemy.deactivate();
			enemies.splice(k, 1);
			continue;
		}
		// Check for destroyed enemies
		if (currentEnemy.toDestroy) {
			currentEnemy.deactivate();
			enemies.splice(k, 1);
			continue;
		}
	}
	// Update fire particles
	for (var m = fireParticles.length - 1; m >= 0; m--) {
		var particle = fireParticles[m];
		particle.update();
		// If particle is done but still in array, remove it
		if (!particle.visible) {
			fireParticles.splice(m, 1);
		}
	}
};
// Start background music
LK.playMusic('gameMusic', {
	fade: {
		start: 0,
		end: 0.3,
		duration: 1000
	}
});

===================================================================
--- original.js
+++ change.js
@@ -112,8 +112,14 @@
 				self.speed = 3;
 				self.health = 1;
 				break;
 		}
+		// Set initial scale based on spawn position
+		var maxDistance = 2732;
+		var distancePercent = self.y / maxDistance;
+		var newScale = 0.3 + distancePercent * (2.0 - 0.3);
+		self.scaleX = newScale;
+		self.scaleY = newScale;
 	};
 	self.update = function () {
 		self.y -= self.speed; // Enemies move up the screen toward the player
 		// Only start scaling when actually on screen