/**** 
* Classes
****/ 
// AimingJoystick class
var AimingJoystick = Container.expand(function () {
	var self = Container.call(this);
	var joystickBackground = self.attachAsset('joystickBackground', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var joystickHandle = self.attachAsset('joystickHandle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = roomWidth - joystickBackground.width / 2 - 100; // Use roomWidth
	self.y = roomHeight - joystickBackground.height / 2 - 100; // Use roomHeight
	var maxRadius = 100;
	var isDragging = false;
	self.down = function (x, y, obj) {
		isDragging = true;
	};
	self.up = function (x, y, obj) {
		isDragging = false;
		joystickHandle.x = 0;
		joystickHandle.y = 0;
	};
	self.move = function (x, y, obj) {
		if (isDragging && !isPopupActive && !isSkillDetailPopupActive) {
			// Check both flags
			var localPos = self.toLocal(obj.global);
			var dx = localPos.x;
			var dy = localPos.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > maxRadius) {
				var angle = Math.atan2(dy, dx);
				dx = maxRadius * Math.cos(angle);
				dy = maxRadius * Math.sin(angle);
			}
			joystickHandle.x = dx;
			joystickHandle.y = dy;
		}
	};
	self.getDirection = function () {
		var magnitude = Math.sqrt(joystickHandle.x * joystickHandle.x + joystickHandle.y * joystickHandle.y);
		if (magnitude > 0) {
			return {
				x: joystickHandle.x / magnitude,
				y: joystickHandle.y / magnitude
			};
		}
		return {
			x: 0,
			y: 0
		};
	};
	self.getRotation = function () {
		if (joystickHandle.x === 0 && joystickHandle.y === 0) {
			return null;
		} // No direction
		return Math.atan2(joystickHandle.y, joystickHandle.x);
	};
	self.hasInput = function () {
		return joystickHandle.x !== 0 || joystickHandle.y !== 0;
	};
	return self;
});
// Arrow class
var Arrow = Container.expand(function () {
	var self = Container.call(this);
	self.attachAsset('arrow', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 15;
	self.damage = 5; // Base damage
	self.update = function () {
		self.x += Math.cos(self.rotation) * self.speed;
		self.y += Math.sin(self.rotation) * self.speed;
		// Check bounds
		if (self.x < 0 || self.x > roomWidth || self.y < 0 || self.y > roomHeight) {
			self.destroy(); // Use built-in destroy if available
			// Remove from arrows array - IMPORTANT!
			var index = arrows.indexOf(self);
			if (index > -1) {
				arrows.splice(index, 1);
			}
		}
	};
	// Overload destroy to ensure removal from array
	var originalDestroy = self.destroy;
	self.destroy = function () {
		var index = arrows.indexOf(self);
		if (index > -1) {
			arrows.splice(index, 1);
		}
		if (originalDestroy) {
			originalDestroy.call(self);
		} // Call original LK destroy
		else if (self.parent) {
			self.parent.removeChild(self);
		} // Manual remove if no built-in destroy
	};
	return self;
});
// BackButton class (for skill tree navigation)
var BackButton = Container.expand(function () {
	var self = Container.call(this);
	self.attachAsset('backButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2,
		scaleY: 2
	});
	self.x = 150;
	self.y = 350; // Position might need adjustment depending on layout
	self.down = function () {
		if (self.parent) {
			menuContainer.removeChild(self.parent); // Remove the specific tree popup
		}
		menuContainer.addChild(skillTreePopup); // Add main selection screen back
		isPopupActive = true; // Main tree is still a popup
		isSkillDetailPopupActive = false; // Ensure detail flag is off
	};
	return self;
});
// Base Enemy class (with shared movement logic)
var BaseEnemy = Container.expand(function () {
	var self = Container.call(this);
	self.speed = 1.0; // Default speed
	self.health = 10; // Default health
	self.damageAmount = 5; // Default damage
	self.damageCooldownTime = 60; // Frames
	self.damageCooldown = 0;
	self.active = true; // Flag if enemy should update
	// --- Shared Methods ---
	self.handleWallCollision = function () {
		var changed = false;
		if (self.x < wallThickness) {
			self.x = wallThickness;
			changed = true;
		}
		if (self.x > roomWidth - wallThickness) {
			self.x = roomWidth - wallThickness;
			changed = true;
		}
		if (self.y < wallThickness) {
			self.y = wallThickness;
			changed = true;
		}
		if (self.y > roomHeight - wallThickness) {
			self.y = roomHeight - wallThickness;
			changed = true;
		}
		return changed; // Return true if position was adjusted
	};
	self.moveTowards = function (targetX, targetY, moveSpeed) {
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0.1) {
			// Avoid division by zero and tiny movements
			self.x += dx / distance * moveSpeed;
			self.y += dy / distance * moveSpeed;
			self.rotation = Math.atan2(dy, dx);
		}
		return distance;
	};
	self.takeDamage = function (amount) {
		self.health -= amount;
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		if (self.active) {
			self.active = false; // Prevent further updates/actions
			currentRoom.enemiesKilled++;
			currentRoom.enemyCounter--; // Decrement active enemy count
			updateRoomDisplay();
			// Remove from room's enemy list AND destroy the object
			var index = currentRoom.enemies.indexOf(self);
			if (index > -1) {
				currentRoom.enemies.splice(index, 1);
			}
			if (self.parent) {
				self.parent.removeChild(self);
			} // Remove from scene graph
			// LK might have a proper destroy method: if (self.destroy) self.destroy();
			checkRoomCleared(); // Check if room is cleared after kill
		}
	};
	// --- Default Update (can be overridden) ---
	self.update = function () {
		if (!self.active || !hero) {
			return;
		} // Basic safety checks
		// Default behavior: Move towards hero
		var offsetX = (Math.random() - 0.5) * 20;
		var offsetY = (Math.random() - 0.5) * 20;
		self.moveTowards(hero.x + offsetX, hero.y + offsetY, self.speed);
		self.handleWallCollision();
	};
	// --- Animation Helper ---
	self.setupAnimation = function (frameAssets) {
		self.frames = frameAssets;
		self.currentFrameIndex = 0;
		self.frameDelay = 30; // Frames per animation frame
		self.frameCounter = 0;
		self.graphics = self.attachAsset(self.frames[0], {
			anchorX: 0.5,
			anchorY: 0.5
		});
	};
	self.updateAnimation = function () {
		if (!self.frames || self.frames.length === 0) {
			return;
		}
		self.frameCounter++;
		if (self.frameCounter >= self.frameDelay) {
			self.frameCounter = 0;
			if (self.graphics) {
				self.removeChild(self.graphics);
			} // Remove old frame
			self.currentFrameIndex = (self.currentFrameIndex + 1) % self.frames.length;
			self.graphics = self.addChild(LK.getAsset(self.frames[self.currentFrameIndex], {
				anchorX: 0.5,
				anchorY: 0.5
			})); // Add new frame asset
		}
	};
	return self;
});
// TankEnemy class
var TankEnemy = BaseEnemy.expand(function () {
	var self = BaseEnemy.call(this);
	// Call base constructor
	self.setupAnimation(['tank_run1', 'tank_run2', 'tank_run3', 'tank_run4']);
	self.speed = 1.0;
	self.health = 50;
	self.damageAmount = 10; // Tank hits harder?
	self.minDistance = 80; // Slightly larger contact distance?
	self.update = function () {
		if (!self.active || !hero) {
			return;
		}
		self.updateAnimation();
		var targetX = hero.x;
		var targetY = hero.y;
		var distance = Math.sqrt(Math.pow(targetX - self.x, 2) + Math.pow(targetY - self.y, 2));
		if (distance > self.minDistance) {
			// Only move if further than min distance
			self.moveTowards(targetX, targetY, self.speed);
		} else {
			// Close enough, deal damage?
			if (self.damageCooldown <= 0) {
				if (hero.takeDamage) {
					hero.takeDamage(self.damageAmount);
				} else {
					hero.health -= self.damageAmount;
				}
				self.damageCooldown = self.damageCooldownTime;
				updateRoomDisplay();
			} else {
				self.damageCooldown--;
			}
			// Tank might not get pushed back, or only slightly
			self.rotation = Math.atan2(targetY - self.y, targetX - self.x); // Keep facing hero
		}
		self.handleWallCollision();
	};
	return self;
});
// RangedEnemy class
var RangedEnemy = BaseEnemy.expand(function () {
	var self = BaseEnemy.call(this);
	// Call base constructor
	self.setupAnimation(['ranged_run1', 'ranged_run2', 'ranged_run3', 'ranged_run4']);
	self.speed = 2.0;
	self.health = 20;
	self.projectileCooldownTime = 180; // 3 seconds at 60 FPS
	self.projectileCooldown = self.projectileCooldownTime; // Start ready? Or random initial cooldown?
	self.desiredDistance = 350; // How far to stay from hero
	self.update = function () {
		if (!self.active || !hero) {
			return;
		}
		self.updateAnimation();
		var targetX = hero.x;
		var targetY = hero.y;
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Movement: Try to maintain desired distance
		if (distance < self.desiredDistance - 10) {
			// Move away if too close (with buffer)
			self.moveTowards(targetX, targetY, -self.speed);
		} else if (distance > self.desiredDistance + 10) {
			// Move closer if too far (with buffer)
			self.moveTowards(targetX, targetY, self.speed);
		} else {
			// Close enough, just rotate to face hero
			self.rotation = Math.atan2(dy, dx);
		}
		self.handleWallCollision();
		// Shooting Logic
		if (self.projectileCooldown <= 0) {
			self.shootProjectile(targetX, targetY);
			self.projectileCooldown = self.projectileCooldownTime;
		} else {
			self.projectileCooldown--;
		}
	};
	self.shootProjectile = function (targetX, targetY) {
		var projectile = new Projectile(); // Create instance
		projectile.x = self.x;
		projectile.y = self.y;
		projectile.damage = self.damageAmount; // Use enemy's damage stat
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var angle = Math.atan2(dy, dx);
		projectile.rotation = angle; // Set initial rotation
		projectile.vx = Math.cos(angle) * projectile.speed;
		projectile.vy = Math.sin(angle) * projectile.speed;
		gameContainer.addChild(projectile); // Add to game world
	};
	return self;
});
// Enemy class (Melee)
var Enemy = BaseEnemy.expand(function () {
	var self = BaseEnemy.call(this);
	// Call base constructor
	self.setupAnimation(['enemy_run1', 'enemy_run2', 'enemy_run3', 'enemy_run4']); // Pass asset names
	self.speed = 2 + Math.random() * 0.5;
	self.health = 10;
	self.damageAmount = 5;
	self.update = function () {
		if (!self.active || !hero) {
			return;
		}
		self.updateAnimation(); // Update visual frame
		var offsetX = (Math.random() - 0.5) * 20;
		var offsetY = (Math.random() - 0.5) * 20;
		var targetX = hero.x + offsetX;
		var targetY = hero.y + offsetY;
		var distance = self.moveTowards(targetX, targetY, self.speed);
		var minDistance = 70;
		if (distance <= minDistance) {
			// Handle being too close (damage hero)
			if (self.damageCooldown <= 0) {
				if (hero.takeDamage) {
					hero.takeDamage(self.damageAmount);
				} // Use hero's method if exists
				else {
					hero.health -= self.damageAmount;
				} // Direct modification fallback
				self.damageCooldown = self.damageCooldownTime;
				updateRoomDisplay(); // Update health display
			} else {
				self.damageCooldown--;
			}
			// Push back slightly
			var pushDx = self.x - targetX;
			var pushDy = self.y - targetY;
			var pushDist = Math.sqrt(pushDx * pushDx + pushDy * pushDy);
			if (pushDist > 0) {
				var pushAmount = (minDistance - distance) * 0.5; // Push back less aggressively
				self.x += pushDx / pushDist * pushAmount;
				self.y += pushDy / pushDist * pushAmount;
			}
		}
		self.handleWallCollision();
	};
	return self;
});
// Hero class
var Hero = Container.expand(function () {
	var self = Container.call(this);
	var heroGraphics = self.attachAsset('hero', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.swordGraphics = heroGraphics.addChild(LK.getAsset('sword', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	self.swordGraphics.x = heroGraphics.width / 2 + 20;
	self.swordGraphics.y = 0;
	self.bowGraphics = self.attachAsset('bow', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.bowGraphics.x = heroGraphics.width / 2; // Adjust position as needed
	self.bowGraphics.visible = false;
	self.attackCooldown = 0;
	self.isAttacking = false; // Specifically for sword swing state
	self.health = 100;
	self.maxHealth = 100; // Add max health for potential healing skills
	self.attackDuration = 20; // Duration of sword swing animation
	self.attackDurationCounter = 0;
	self.weaponType = 1; // 1: Sword, 2: Bow
	self.attackRange = 60; // Sword range
	self.attackDamage = 10; // Base damage
	self.speed = 3;
	self.swordAttackSpeed = 45; // Cooldown frames for sword
	self.bowAttackSpeed = 30; // Cooldown frames for bow
	self.joystick = null; // Movement joystick ref
	self.aimingJoystick = null; // Aiming joystick ref
	self.facingDirection = 0; // For movement rotation when not aiming
	self.canExitRoom = false; // Flag set when room is cleared
	// Method to take damage
	self.takeDamage = function (amount) {
		self.health -= amount;
		if (self.health < 0) {
			self.health = 0;
		}
		updateRoomDisplay(); // Update health text
		if (self.health <= 0) {
			LK.showGameOver(); // Handle death
		}
	};
	self.update = function () {
		if (self.health <= 0) {
			return;
		} // Don't update if dead
		// --- Movement ---
		var moveDirection = self.joystick ? self.joystick.getDirection() : {
			x: 0,
			y: 0
		};
		var nextX = self.x + moveDirection.x * self.speed;
		var nextY = self.y + moveDirection.y * self.speed;
		// --- Wall Collision & Room Transition Check ---
		var onEntrance = false;
		if (nextX < wallThickness) {
			if (nextY >= entrances.left.yStart && nextY <= entrances.left.yEnd) {
				onEntrance = true;
			} else {
				nextX = wallThickness;
			}
		} else if (nextX > roomWidth - wallThickness) {
			if (nextY >= entrances.right.yStart && nextY <= entrances.right.yEnd) {
				onEntrance = true;
			} else {
				nextX = roomWidth - wallThickness;
			}
		}
		if (nextY < wallThickness) {
			if (nextX >= entrances.top.xStart && nextX <= entrances.top.xEnd) {
				onEntrance = true;
			} else {
				nextY = wallThickness;
			}
		} else if (nextY > roomHeight - wallThickness) {
			if (nextX >= entrances.bottom.xStart && nextX <= entrances.bottom.xEnd) {
				onEntrance = true;
			} else {
				nextY = roomHeight - wallThickness;
			}
		}
		self.x = nextX;
		self.y = nextY;
		// Handle Room Transition (Moved here from game.update)
		if (self.canExitRoom && onEntrance) {
			// Determine exit side based on final position near edge
			var exitSide = '';
			if (self.y < wallThickness + 10) {
				exitSide = 'top';
			} // Exiting top
			else if (self.y > roomHeight - wallThickness - 10) {
				exitSide = 'bottom';
			} // Exiting bottom
			else if (self.x < wallThickness + 10) {
				exitSide = 'left';
			} // Exiting left
			else if (self.x > roomWidth - wallThickness - 10) {
				exitSide = 'right';
			} // Exiting right
			if (exitSide) {
				// Determine entry side for the *next* room
				var entrySide = '';
				if (exitSide === 'top') {
					entrySide = 'bottom';
				} else if (exitSide === 'bottom') {
					entrySide = 'top';
				} else if (exitSide === 'left') {
					entrySide = 'right';
				} else if (exitSide === 'right') {
					entrySide = 'left';
				}
				transitionToNewRoom(entrySide); // Trigger transition
				return; // Stop further updates this frame after transition
			}
		}
		// --- Rotation & Aiming ---
		var isMoving = moveDirection.x !== 0 || moveDirection.y !== 0;
		var isAiming = self.aimingJoystick && self.aimingJoystick.hasInput();
		var aimAngle = isAiming ? self.aimingJoystick.getRotation() : null;
		if (isMoving) {
			self.facingDirection = Math.atan2(moveDirection.y, moveDirection.x);
		}
		// Set hero rotation: Aiming takes priority
		if (isAiming && aimAngle !== null) {
			self.rotation = aimAngle;
			// Position weapons based on aim direction (simplified for now)
			if (self.weaponType === 1) {
				// Sword
				self.swordGraphics.rotation = 0; // Base rotation relative to hero
			} else {
				// Bow
				self.bowGraphics.rotation = 0; // Base rotation relative to hero
			}
		} else if (isMoving) {
			self.rotation = self.facingDirection; // Rotate based on movement if not aiming
		}
		// If not aiming and not moving, hero keeps last rotation
		// --- Attack Logic ---
		if (!isPopupActive && !isSkillDetailPopupActive) {
			// Check both flags
			if (self.attackCooldown > 0) {
				self.attackCooldown--;
			}
			// Determine attack target direction (aiming joystick or facing direction)
			var attackAngle = isAiming && aimAngle !== null ? aimAngle : self.rotation;
			// Sword Attack
			if (self.weaponType === 1) {
				if (self.isAttacking) {
					// Continue existing swing animation
					if (self.attackDurationCounter > 0) {
						self.attackDurationCounter--;
						var swingProgress = (self.attackDuration - self.attackDurationCounter) / self.attackDuration;
						// Simple swing animation
						self.swordGraphics.rotation = Math.sin(swingProgress * Math.PI) * 1.2; // Swing arc
						// Check for hits during the swing (e.g., mid-swing)
						if (swingProgress > 0.3 && swingProgress < 0.7) {
							// Check during the active part of swing
							self.checkSwordHits(attackAngle);
						}
					} else {
						// Swing finished
						self.isAttacking = false;
						self.swordGraphics.rotation = 0;
						self.attackCooldown = self.swordAttackSpeed; // Set cooldown AFTER swing finishes
					}
				} else if (self.attackCooldown <= 0) {
					// Start new swing if ready
					self.isAttacking = true;
					self.attackDurationCounter = self.attackDuration;
					// Play swing sound?
				}
			}
			// Bow Attack
			else if (self.weaponType === 2) {
				if (self.attackCooldown <= 0 && (isAiming || isMoving)) {
					// Require aim input or movement to fire bow? Or always fire? Assuming requires input/movement for now.
					self.fireArrow(attackAngle);
					self.attackCooldown = self.bowAttackSpeed;
					// Play shoot sound?
				}
			}
		} else {
			// Ensure attack state is reset if popup becomes active mid-swing
			if (self.isAttacking) {
				self.isAttacking = false;
				self.swordGraphics.rotation = 0;
				self.attackDurationCounter = 0;
				// Don't set cooldown here, might allow instant attack when popup closes
			}
		}
	}; // End of update function
	// --- Helper Methods ---
	self.checkSwordHits = function (attackAngle) {
		for (var i = currentRoom.enemies.length - 1; i >= 0; i--) {
			var enemy = currentRoom.enemies[i];
			if (!enemy || !enemy.active) {
				continue;
			}
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distSqr = dx * dx + dy * dy; // Use squared distance for efficiency
			var rangeSqr = self.attackRange * self.attackRange;
			if (distSqr < rangeSqr) {
				var angleToEnemy = Math.atan2(dy, dx);
				// Calculate difference in angle, wrap around PI
				var angleDifference = Math.atan2(Math.sin(angleToEnemy - attackAngle), Math.cos(angleToEnemy - attackAngle));
				if (Math.abs(angleDifference) < Math.PI / 4) {
					// Check if enemy is within 45-degree cone
					if (enemy.takeDamage) {
						enemy.takeDamage(self.attackDamage);
					}
					// Prevent hitting same enemy multiple times per swing - requires tracking hits
					// For simplicity now, we hit every frame check within the swing arc.
					// A better way: track which enemies were hit *this swing*.
				}
			}
		}
	};
	self.fireArrow = function (fireAngle) {
		if (self.weaponType !== 2) {
			return;
		}
		var arrow = new Arrow();
		arrow.x = self.x + Math.cos(fireAngle) * 30; // Start slightly ahead
		arrow.y = self.y + Math.sin(fireAngle) * 30;
		arrow.rotation = fireAngle;
		arrow.damage = self.attackDamage; // Use hero's damage
		arrows.push(arrow); // Add to global array
		gameContainer.addChild(arrow); // Add to scene
	};
	self.switchWeapon = function () {
		self.weaponType = self.weaponType === 1 ? 2 : 1;
		self.swordGraphics.visible = self.weaponType === 1;
		self.bowGraphics.visible = self.weaponType === 2;
		self.isAttacking = false; // Reset sword attack state
		self.attackDurationCounter = 0;
		self.attackCooldown = 0; // Allow immediate attack with new weapon? Or add small delay?
	};
	return self;
});
// Joystick class (Movement)
var Joystick = Container.expand(function () {
	var self = Container.call(this);
	var joystickBackground = self.attachAsset('joystickBackground', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var joystickHandle = self.attachAsset('joystickHandle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = joystickBackground.width / 2 + 100;
	self.y = roomHeight - joystickBackground.height / 2 - 100; // Use roomHeight
	var maxRadius = 100;
	var isDragging = false;
	self.down = function (x, y, obj) {
		isDragging = true;
	};
	self.up = function (x, y, obj) {
		isDragging = false;
		joystickHandle.x = 0;
		joystickHandle.y = 0;
	};
	self.move = function (x, y, obj) {
		if (isDragging && !isPopupActive && !isSkillDetailPopupActive) {
			// Check both flags
			var localPos = self.toLocal(obj.global);
			var dx = localPos.x;
			var dy = localPos.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > maxRadius) {
				var angle = Math.atan2(dy, dx);
				dx = maxRadius * Math.cos(angle);
				dy = maxRadius * Math.sin(angle);
			}
			joystickHandle.x = dx;
			joystickHandle.y = dy;
		}
	};
	self.getDirection = function () {
		var magnitude = Math.sqrt(joystickHandle.x * joystickHandle.x + joystickHandle.y * joystickHandle.y);
		if (magnitude > 0) {
			return {
				x: joystickHandle.x / magnitude,
				y: joystickHandle.y / magnitude
			};
		}
		return {
			x: 0,
			y: 0
		};
	};
	return self;
});
// Projectile class (Enemy ranged attack)
var Projectile = Container.expand(function () {
	var self = Container.call(this);
	self.attachAsset('ranged_attack', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	self.damage = 5;
	self.vx = 0; // Velocity components
	self.vy = 0;
	self.update = function () {
		self.x += self.vx;
		self.y += self.vy;
		self.rotation += 0.1; // Spin effect
		// Boundary check
		if (self.x < 0 || self.x > roomWidth || self.y < 0 || self.y > roomHeight) {
			if (self.parent) {
				self.parent.removeChild(self);
			} // Destroy if out of bounds
			// No need to remove from an array if not tracked globally
			return;
		}
		// Collision check with hero
		if (hero && self.intersects && self.intersects(hero)) {
			// Check intersects exists
			if (hero.takeDamage) {
				hero.takeDamage(self.damage);
			} else {
				hero.health -= self.damage;
			}
			updateRoomDisplay();
			if (self.parent) {
				self.parent.removeChild(self);
			} // Destroy on hit
		}
	};
	return self;
});
// StartGameButton class
var StartGameButton = Container.expand(function () {
	var self = Container.call(this);
	self.attachAsset('startGameButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 3,
		scaleY: 3
	});
	self.x = roomWidth / 2;
	self.y = roomHeight - 400;
	self.down = function () {
		if (self.parent) {
			menuContainer.removeChild(self.parent);
		} // Remove the popup it's on (main skill tree)
		isPopupActive = false; // No longer in menu
		isSkillDetailPopupActive = false;
		initializeGame(); // Start the actual game
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// -- Symphony of Shadows Icons --
// -- Nexus of Chaos Icons --
// -- Prism of Potential Icons --
// -- Forge of Possibilities Icons --
// -- Echoes of Ancestry Icons --
// -- Circuit of Ascension Icons --
// -- Symphony of Shadows Icons --
// -- Nexus of Chaos Icons --
// -- Prism of Potential Icons --
// -- Forge of Possibilities Icons --
// -- Echoes of Ancestry Icons --
// -- Circuit of Ascension Icons --
// Made it grey
// Add containers to the game stage
// Adjusted default size
/**** 
* Game Configuration & Data
****/ 
var roomWidth = 2048;
var roomHeight = 2732;
var wallThickness = 400;
var entranceWidth = 200;
var entrances = {
	top: {
		xStart: (roomWidth - entranceWidth) / 2,
		xEnd: (roomWidth + entranceWidth) / 2,
		y: wallThickness
	},
	bottom: {
		xStart: (roomWidth - entranceWidth) / 2,
		xEnd: (roomWidth + entranceWidth) / 2,
		y: roomHeight - wallThickness
	},
	left: {
		yStart: (roomHeight - entranceWidth) / 2,
		yEnd: (roomHeight + entranceWidth) / 2,
		x: wallThickness
	},
	right: {
		yStart: (roomHeight - entranceWidth) / 2,
		yEnd: (roomHeight + entranceWidth) / 2,
		x: roomWidth - wallThickness
	}
};
var spawnPoints = {
	topLeft: {
		x: wallThickness + 50,
		y: wallThickness + 50
	},
	// Offset slightly from corner
	topRight: {
		x: roomWidth - wallThickness - 50,
		y: wallThickness + 50
	},
	bottomLeft: {
		x: wallThickness + 50,
		y: roomHeight - wallThickness - 50
	},
	bottomRight: {
		x: roomWidth - wallThickness - 50,
		y: roomHeight - wallThickness - 50
	}
};
var roomBackgroundImages = ['backgroundImage1', 'backgroundImage2', 'backgroundImage3', 'backgroundImage4', 'backgroundImage5'];
var totalRooms = 5;
// --- Centralized Skill Data ---
var heroSkillPoints = 3; // Starting skill points
var skillDefinitions = {
	// --- Circuit of Ascension ---
	'Data Spike': {
		points: 0,
		max: 5,
		tree: 'The Circuit of Ascension',
		calcData: {
			increases: [5, 4, 3, 2, 1]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentBenefit = 0;
			for (var i = 0; i < points; i++) {
				currentBenefit += calcData.increases[i];
			}
			if (points < this.max) {
				var nextIncrease = calcData.increases[points];
				return points === 0 ? 'Increases critical strike chance by 5%.' : 'Increases critical strike chance by ' + nextIncrease + '%. (Currently ' + currentBenefit + '%)';
			} else {
				return 'Maximum rank reached. Your critical hit chance is increased by 15%.';
			}
		}
	},
	'Reflex Accelerator': {
		points: 0,
		max: 5,
		tree: 'The Circuit of Ascension',
		calcData: {
			increases: [10, 8, 6, 4, 2]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentBenefit = 0;
			for (var i = 0; i < points; i++) {
				currentBenefit += calcData.increases[i];
			}
			if (points < this.max) {
				var nextIncrease = calcData.increases[points];
				return points === 0 ? 'Boosts movement speed by 10%.' : 'Boosts movement speed by ' + nextIncrease + '% (Currently ' + currentBenefit + '%)';
			} else {
				return 'Maximum rank reached. Your movement speed is increased by 30%.';
			}
		}
	},
	'Overclock Core': {
		points: 0,
		max: 5,
		tree: 'The Circuit of Ascension',
		calcData: {
			attackSpeedIncreases: [2.5, 2.0, 1.5, 1.0, 0.5],
			energyRegenIncreases: [2.0, 1.6, 1.2, 0.8, 0.4]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentAttackSpeedBenefit = 0;
			var currentEnergyRegenBenefit = 0;
			for (var i = 0; i < points; i++) {
				currentAttackSpeedBenefit += calcData.attackSpeedIncreases[i];
				currentEnergyRegenBenefit += calcData.energyRegenIncreases[i];
			}
			if (points < this.max) {
				var nextAttackSpeedIncrease = calcData.attackSpeedIncreases[points];
				var nextEnergyRegenIncrease = calcData.energyRegenIncreases[points];
				return points === 0 ? 'Increases attack speed by ' + nextAttackSpeedIncrease.toFixed(1) + '% and energy regeneration by ' + nextEnergyRegenIncrease.toFixed(1) + '%.' : 'Increases attack speed by ' + nextAttackSpeedIncrease.toFixed(1) + '% and energy regeneration by ' + nextEnergyRegenIncrease.toFixed(1) + '% (Currently ' + currentAttackSpeedBenefit.toFixed(1) + '% / ' + currentEnergyRegenBenefit.toFixed(1) + '%).';
			} else {
				return 'Maximum rank reached. Your attack speed is increased by 7.5% and energy regeneration by 6.0%.';
			}
		}
	},
	'Neural Hijack': {
		points: 0,
		max: 5,
		tree: 'The Circuit of Ascension',
		calcData: {
			durationIncreases: [3, 4, 5, 6, 8],
			cooldownDecreases: [30, 27, 24, 21, 15]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentDuration = 0;
			var currentCooldown = 0;
			if (points > 0) {
				currentDuration = calcData.durationIncreases[points - 1];
				currentCooldown = calcData.cooldownDecreases[points - 1];
			}
			if (points < this.max) {
				var nextDuration = calcData.durationIncreases[points];
				var nextCooldown = calcData.cooldownDecreases[points];
				return points === 0 ? 'Temporarily converts an enemy to fight for you for ' + nextDuration + ' seconds (Cooldown: ' + nextCooldown + 's).' : 'Converts an enemy for ' + nextDuration + ' seconds (Cooldown: ' + nextCooldown + 's) (Currently ' + currentDuration + 's / ' + currentCooldown + 's).';
			} else {
				return 'Maximum rank reached. Converts an enemy to fight for you for 8 seconds with a 15 second cooldown.';
			}
		}
	},
	'Dodge Matrix': {
		points: 0,
		max: 5,
		tree: 'The Circuit of Ascension',
		calcData: {
			increases: [10, 8, 6, 4, 2]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentBenefit = 0;
			for (var i = 0; i < points; i++) {
				currentBenefit += calcData.increases[i];
			}
			if (points < this.max) {
				var nextIncrease = calcData.increases[points];
				return points === 0 ? 'Grants a 10% chance to dodge enemy attacks.' : 'Grants an additional ' + nextIncrease + '% chance to dodge enemy attacks (Currently ' + currentBenefit + '%)';
			} else {
				return 'Maximum rank reached. Your chance to dodge enemy attacks is increased by 30%.';
			}
		}
	},
	'Power Surge': {
		points: 0,
		max: 5,
		tree: 'The Circuit of Ascension',
		calcData: {
			damageMultipliers: [1.0, 1.25, 1.5, 1.75, 2.0],
			radiusSizes: [2.0, 2.5, 3.0, 3.5, 4.0]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentDamageMultiplier = 0;
			var currentRadius = 0;
			if (points > 0) {
				currentDamageMultiplier = calcData.damageMultipliers[points - 1];
				currentRadius = calcData.radiusSizes[points - 1];
			}
			if (points < this.max) {
				var nextDamageMultiplier = calcData.damageMultipliers[points];
				var nextRadius = calcData.radiusSizes[points];
				return points === 0 ? 'Releases an energy burst dealing 100% magic damage in a 2.0-unit radius.' : 'Deals ' + (nextDamageMultiplier * 100).toFixed(0) + '% magic damage in a ' + nextRadius.toFixed(1) + '-unit radius (Currently ' + (currentDamageMultiplier * 100).toFixed(0) + '% / ' + currentRadius.toFixed(1) + ')';
			} else {
				return 'Maximum rank reached. Your energy burst deals 200% magic damage in a 4.0-unit radius.';
			} // Corrected max description based on arrays
		}
	},
	'Overload Blast': {
		points: 0,
		max: 1,
		tree: 'The Circuit of Ascension',
		descriptionFn: function descriptionFn(points, calcData) {
			return 'Unleashes a massive explosion, dealing 300% fire damage to all enemies in the room (Cooldown: 60s).';
		}
	},
	// --- Echoes of Ancestry ---
	'Ancient Wisdom': {
		points: 0,
		max: 5,
		tree: 'The Echoes of Ancestry',
		calcData: {
			increases: [5, 4, 3, 2, 1]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentBenefit = 0;
			for (var i = 0; i < points; i++) {
				currentBenefit += calcData.increases[i];
			}
			if (points < this.max) {
				var nextIncrease = calcData.increases[points];
				return points === 0 ? 'Increases elemental critical hit chance by 5%.' : 'Increases elemental critical hit chance by ' + nextIncrease + '% (Currently ' + currentBenefit + '%).';
			} else {
				return 'Maximum rank reached. Increases elemental critical hit chance by 15%.';
			}
		}
	},
	'Elemental Mastery': {
		points: 0,
		max: 5,
		tree: 'The Echoes of Ancestry',
		calcData: {
			increases: [10, 8, 6, 4, 2]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentBenefit = 0;
			for (var i = 0; i < points; i++) {
				currentBenefit += calcData.increases[i];
			}
			if (points < this.max) {
				var nextIncrease = calcData.increases[points];
				return points === 0 ? 'Increases elemental damage by 10%.' : 'Increases elemental damage by ' + nextIncrease + '% (Currently ' + currentBenefit + '%).';
			} else {
				return 'Maximum rank reached. Increases elemental damage by 30%.';
			}
		}
	},
	'Warrior Spirit': {
		points: 0,
		max: 5,
		tree: 'The Echoes of Ancestry',
		calcData: {
			increases: [10, 8, 6, 4, 2]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentBenefit = 0;
			for (var i = 0; i < points; i++) {
				currentBenefit += calcData.increases[i];
			}
			if (points < this.max) {
				var nextIncrease = calcData.increases[points];
				return points === 0 ? 'Increases melee attack speed by 10%.' : 'Increases melee attack speed by ' + nextIncrease + '% (Currently ' + currentBenefit + '%).';
			} else {
				return 'Maximum rank reached. Increases melee attack speed by 30%.';
			}
		}
	},
	'Beast Tamer': {
		points: 0,
		max: 5,
		tree: 'The Echoes of Ancestry',
		calcData: {
			durations: [2, 3, 4, 4, 4],
			cooldowns: [20, 18, 16, 16, 16]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentDuration = 0;
			var currentCooldown = 0;
			if (points > 0) {
				currentDuration = calcData.durations[points - 1];
				currentCooldown = calcData.cooldowns[points - 1];
			}
			if (points < this.max) {
				var nextDuration = calcData.durations[points];
				var nextCooldown = calcData.cooldowns[points];
				return points === 0 ? 'Summons a spirit beast for 2 seconds (Cooldown: 20s).' : 'Summons a spirit beast for ' + nextDuration + ' seconds (Cooldown: ' + nextCooldown + 's) (Currently ' + currentDuration + 's / ' + currentCooldown + 's).';
			} else {
				return 'Maximum rank reached. Summons a spirit beast for 4 seconds (Cooldown: 16s).';
			}
		}
	},
	'Herbal Remedies': {
		points: 0,
		max: 5,
		tree: 'The Echoes of Ancestry',
		calcData: {
			increases: [0.5, 0.6, 0.7, 0.8, 1.0]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentBenefit = 0;
			if (points > 0) {
				currentBenefit = calcData.increases[points - 1];
			}
			if (points < this.max) {
				var nextIncrease = calcData.increases[points];
				return points === 0 ? 'Heals 0.5% of max HP per second during combat.' : 'Heals ' + nextIncrease.toFixed(1) + '% of max HP per second (Currently ' + currentBenefit.toFixed(1) + '%).';
			} else {
				return 'Maximum rank reached. Heals 1.0% of max HP per second during combat.';
			}
		}
	},
	'Spirit Guidance': {
		points: 0,
		max: 5,
		tree: 'The Echoes of Ancestry',
		calcData: {
			reductions: [5, 4, 3, 2, 1]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentBenefit = 0;
			for (var i = 0; i < points; i++) {
				currentBenefit += calcData.reductions[i];
			}
			if (points < this.max) {
				var nextReduction = calcData.reductions[points];
				return points === 0 ? 'Reduces incoming damage by 5%.' : 'Reduces incoming damage by ' + nextReduction + '% (Currently ' + currentBenefit + '%).';
			} else {
				return 'Maximum rank reached. Reduces incoming damage by 15%.';
			}
		}
	},
	'Legendary Ancestor': {
		points: 0,
		max: 1,
		tree: 'The Echoes of Ancestry',
		descriptionFn: function descriptionFn(points, calcData) {
			return 'Temporarily increases your damage by 100% and defense by 50% for 6 seconds (Cooldown: 60s).';
		}
	},
	// --- Forge of Possibilities ---
	'Adaptive Construction': {
		points: 0,
		max: 5,
		tree: 'The Forge of Possibilities',
		calcData: {
			fireDmgPerRank: 5,
			ignitePerRank: 2
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentFire = points * calcData.fireDmgPerRank;
			var currentIgnite = points * calcData.ignitePerRank;
			if (points === 0) {
				return "Imbue your weapon with searing flame, adding 5% fire damage and 2% chance to ignite on hit.";
			} else if (points < this.max) {
				return "Imbue your weapon with searing flame, adding " + (points + 1) * calcData.fireDmgPerRank + "% fire damage and " + (points + 1) * calcData.ignitePerRank + "% chance to ignite on hit (Currently " + currentFire + "% fire damage / " + currentIgnite + "% ignite).";
			} else {
				return "Maximum rank reached. Imbue your weapon with searing flame, adding 25% fire damage and 10% chance to ignite on hit.";
			}
		}
	},
	'Elemental Infusion': {
		points: 0,
		max: 5,
		tree: 'The Forge of Possibilities',
		calcData: {
			procs: [10, 8, 6, 4, 2]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentProc = 0;
			for (var i = 0; i < points; i++) {
				currentProc += calcData.procs[i];
			}
			if (points === 0) {
				return "Every attack has a 10% chance to inflict a random elemental effect.";
			} else if (points < this.max) {
				var nextProc = calcData.procs[points];
				return "Every attack has a " + (currentProc + nextProc) + "% chance to inflict a random elemental effect (Currently " + currentProc + "%).";
			} else {
				return "Maximum rank reached. Every attack has a 30% chance to inflict a random elemental effect.";
			}
		}
	},
	'Modular Enhancement': {
		points: 0,
		max: 5,
		tree: 'The Forge of Possibilities',
		calcData: {
			procPerRank: 3
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentProc = points * calcData.procPerRank;
			if (points === 0) {
				return "Each hit has a 3% chance to instantly ready your weapon for an extra strike.";
			} else if (points < this.max) {
				return "Each hit has a " + (points + 1) * calcData.procPerRank + "% chance to instantly ready your weapon for an extra strike (Currently " + currentProc + "%).";
			} else {
				return "Maximum rank reached. Each hit has a 15% chance to instantly ready your weapon for an extra strike.";
			}
		}
	},
	'Resourceful Salvage': {
		points: 0,
		max: 5,
		tree: 'The Forge of Possibilities',
		calcData: {
			procChances: [2, 3, 4, 5, 6],
			buffStrengths: [10, 12, 14, 16, 20],
			buffDurations: [5, 7, 9, 12, 15]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentProc = 0,
				currentBuff = 0,
				currentDur = 0;
			if (points > 0) {
				currentProc = calcData.procChances[points - 1];
				currentBuff = calcData.buffStrengths[points - 1];
				currentDur = calcData.buffDurations[points - 1];
			}
			if (points === 0) {
				return "Killing an enemy has a 2% chance to grant +10% skill‑point gain for 5 seconds.";
			} else if (points < this.max) {
				var nextProc = calcData.procChances[points];
				var nextBuff = calcData.buffStrengths[points];
				var nextDur = calcData.buffDurations[points];
				return "Killing an enemy has a " + nextProc + "% chance to grant +" + nextBuff + "% skill‑point gain for " + nextDur + " seconds (Currently " + currentProc + "% / +" + currentBuff + "% / " + currentDur + "s).";
			} else {
				return "Maximum rank reached. Killing an enemy has a 6% chance to grant +20% skill‑point gain for 15 seconds.";
			}
		}
	},
	'Hybrid Crafting': {
		// NOTE: Original code had max 5, description implies max 1. Assuming max 1.
		points: 0,
		max: 1,
		tree: 'The Forge of Possibilities',
		descriptionFn: function descriptionFn(points, calcData) {
			return 'Fuse melee and ranged traits: your arrows cleave a nearby target at short range (30% splash), and sword swings have a 20% chance to fire a projectile at 50% damage.';
		}
	},
	'Runic Slots': {
		// Renamed from Gem Harvester based on original code usage
		points: 0,
		max: 5,
		tree: 'The Forge of Possibilities',
		calcData: {
			dropChances: [5, 8, 12, 16, 20],
			buffPotencies: [5, 7, 9, 12, 15],
			buffDurations: [3, 4, 5, 6, 8]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			var currentDrop = 0,
				currentBuff = 0,
				currentDur = 0;
			if (points > 0) {
				currentDrop = calcData.dropChances[points - 1];
				currentBuff = calcData.buffPotencies[points - 1];
				currentDur = calcData.buffDurations[points - 1];
			}
			if (points === 0) {
				return "Killing an enemy has a 5% chance to drop a runic gem granting a random +5% buff for 3 seconds.";
			} else if (points < this.max) {
				var nextDrop = calcData.dropChances[points];
				var nextBuff = calcData.buffPotencies[points];
				var nextDur = calcData.buffDurations[points];
				return "Killing an enemy has an " + nextDrop + "% chance to drop a runic gem granting a random +" + nextBuff + "% buff for " + nextDur + " seconds (Currently " + currentDrop + "% / +" + currentBuff + "% / " + currentDur + "s).";
			} else {
				return "Maximum rank reached. Killing an enemy has a 20% chance to drop a runic gem granting a random +15% buff for 8 seconds.";
			}
		}
	},
	'Masterwork Creation': {
		// NOTE: Original code had max 5, description implies max 3. Assuming max 3.
		points: 0,
		max: 3,
		tree: 'The Forge of Possibilities',
		calcData: {
			dmgBonuses: [30, 60, 90],
			cleaveCounts: [1, 2, 3],
			shockwaveRadii: [1, 2, 3]
		},
		descriptionFn: function descriptionFn(points, calcData) {
			if (points === 0) {
				return "Transforms your weapon for 6s, granting +30% damage, arrows cleave 1 extra target, and melee triggers a 1‑unit shockwave (Cooldown: 60s).";
			} else if (points < this.max) {
				var currentDmg = calcData.dmgBonuses[points - 1];
				var currentCleave = calcData.cleaveCounts[points - 1];
				var currentRadius = calcData.shockwaveRadii[points - 1];
				var nextDmg = calcData.dmgBonuses[points];
				var nextCleave = calcData.cleaveCounts[points];
				var nextRadius = calcData.shockwaveRadii[points];
				return "Transforms your weapon for 6s, granting +" + nextDmg + "% damage, arrows cleave " + nextCleave + " extra target" + (nextCleave > 1 ? "s" : "") + ", and melee triggers a " + nextRadius + "-unit shockwave (Currently +" + currentDmg + "% / " + currentCleave + " cleave / " + currentRadius + "-unit shockwave). Cooldown: 60s.";
			} else {
				return "Maximum rank reached. Transforms your weapon for 6s, granting +90% damage, arrows cleave 3 extra targets, and melee triggers a 3‑unit shockwave (Cooldown: 60s).";
			}
		}
	},
	// --- Prism of Potential --- (Assuming all max 5, simple descriptions for now)
	'Red Radiance': {
		points: 0,
		max: 5,
		tree: 'The Prism of Potential',
		descriptionFn: function descriptionFn(p, d) {
			return 'Channel the crimson energy of aggression. Increases your attack damage slightly and grants a chance for attacks to ignite enemies, causing minor burn damage over time.';
		}
	},
	'Blue Bulwark': {
		points: 0,
		max: 5,
		tree: 'The Prism of Potential',
		descriptionFn: function descriptionFn(p, d) {
			return 'Embrace cerulean hues of defense. Enhances your armor and magic resistance for a short duration, reducing incoming damage and occasionally shielding you with a barrier of ice.';
		}
	},
	'Green Growth': {
		points: 0,
		max: 5,
		tree: 'The Prism of Potential',
		descriptionFn: function descriptionFn(p, d) {
			return 'Tap into verdant life essence. Gradually regenerates a portion of your health and grants a chance for attacks to apply a minor heal-over-time effect to yourself or nearby allies.';
		}
	},
	'Yellow Zephyr': {
		points: 0,
		max: 5,
		tree: 'The Prism of Potential',
		descriptionFn: function descriptionFn(p, d) {
			return 'Harness the swiftness of golden winds. Boosts your movement speed slightly and improves your bow’s draw rate or sword swing speed, letting you dart around combat swiftly.';
		}
	},
	'Indigo Insight': {
		points: 0,
		max: 5,
		tree: 'The Prism of Potential',
		descriptionFn: function descriptionFn(p, d) {
			return 'Draw from deep indigo wisdom. Grants increased critical hit chance and a small probability to reflect a portion of incoming damage back at your attacker, showcasing keen foresight.';
		}
	},
	'Chromatic Fusion': {
		points: 0,
		max: 5,
		tree: 'The Prism of Potential',
		descriptionFn: function descriptionFn(p, d) {
			return 'Blend two chosen elemental colors (e.g., Red and Blue) to create a hybrid effect. Depending on the combination, gain unique bonuses, such as fiery storms or frostburn effects, strengthening both offense and defense.';
		}
	},
	'Prismatic Ascendance': {
		points: 0,
		max: 5,
		tree: 'The Prism of Potential',
		descriptionFn: function descriptionFn(p, d) {
			return 'Briefly harness all hues at once, greatly enhancing elemental power. Attacks may inflict multiple ailments, and you gain increased damage, defense, healing, and speed.';
		}
	},
	// --- Nexus of Chaos --- (Assuming all max 5, simple descriptions for now)
	'Chaotic Spark': {
		points: 0,
		max: 5,
		tree: 'The Nexus of Chaos',
		descriptionFn: function descriptionFn(p, d) {
			return 'Your attacks sometimes produce random elemental effects. Damage types and minor status effects vary unpredictably, keeping foes off-balance.';
		}
	},
	'Entropy Shield': {
		points: 0,
		max: 5,
		tree: 'The Nexus of Chaos',
		descriptionFn: function descriptionFn(p, d) {
			return 'Surround yourself with shifting energy fields. Each incoming hit has a chance to fizzle harmlessly or rebound, dealing random damage back to attackers.';
		}
	},
	'Unstable Rift': {
		points: 0,
		max: 5,
		tree: 'The Nexus of Chaos',
		descriptionFn: function descriptionFn(p, d) {
			return 'Occasionally summon a pocket of chaos in battle. Enemies near the rift suffer random debuffs—slowing, poisoning, burning—ever-changing, never stable.';
		}
	},
	'Anomaly Shift': {
		points: 0,
		max: 5,
		tree: 'The Nexus of Chaos',
		descriptionFn: function descriptionFn(p, d) {
			return 'Briefly warp your form. Gain random beneficial buffs—from speed and regeneration to critical chance—but each application is uncertain, never guaranteed.';
		}
	},
	'Cascade of Disorder': {
		points: 0,
		max: 5,
		tree: 'The Nexus of Chaos',
		descriptionFn: function descriptionFn(p, d) {
			return 'Trigger a chain reaction of volatile energies. Attacks may ignite unpredictable chain effects, spreading to multiple enemies or amplifying certain strikes.';
		}
	},
	'Fractured Fate': {
		points: 0,
		max: 5,
		tree: 'The Nexus of Chaos',
		descriptionFn: function descriptionFn(p, d) {
			return 'Tap into temporal chaos. Sometimes attacks hit twice, or cooldowns shorten unexpectedly. Fate bends momentarily, granting you unpredictable bursts of advantage.';
		}
	},
	'Reality Collapse': {
		points: 0,
		max: 5,
		tree: 'The Nexus of Chaos',
		descriptionFn: function descriptionFn(p, d) {
			return 'For a short time, unravel normal rules. Attacks ignore some defenses, enemies may lose control, and your random benefits intensify. Chaos reigns supreme, leaving foes disoriented and vulnerable.';
		}
	},
	// --- Symphony of Shadows --- (Assuming all max 5, simple descriptions for now)
	'Whispered Steps': {
		points: 0,
		max: 5,
		tree: 'The Symphony of Shadows',
		descriptionFn: function descriptionFn(p, d) {
			return 'Move silently, becoming harder to detect. Occasionally evade attacks entirely, as your footsteps blend into the ambient darkness.';
		}
	},
	'Nightfall Veil': {
		points: 0,
		max: 5,
		tree: 'The Symphony of Shadows',
		descriptionFn: function descriptionFn(p, d) {
			return 'Briefly cloak yourself in shadow. While cloaked, project a faint silhouette to mislead foes. Attacks aimed at you may strike only empty air.';
		}
	},
	'Serrated Shade': {
		points: 0,
		max: 5,
		tree: 'The Symphony of Shadows',
		descriptionFn: function descriptionFn(p, d) {
			return 'Enhance your weapons with shadowy edges. Attacks may lacerate enemies, causing bleed-like damage over time as the darkness seeps into their wounds.';
		}
	},
	'Shadow Familiar': {
		points: 0,
		max: 5,
		tree: 'The Symphony of Shadows',
		descriptionFn: function descriptionFn(p, d) {
			return 'Summon a small, dark entity that assists you. It distracts enemies, occasionally nipping at their heels and granting you openings to strike.';
		}
	},
	'Muffled Strikes': {
		points: 0,
		max: 5,
		tree: 'The Symphony of Shadows',
		descriptionFn: function descriptionFn(p, d) {
			return 'Attacks produce little sound, reducing enemy awareness. Some foes fail to fully react, taking extra critical hits as they struggle to track your movements.';
		}
	},
	'Umbral Echoes': {
		points: 0,
		max: 5,
		tree: 'The Symphony of Shadows',
		descriptionFn: function descriptionFn(p, d) {
			return 'Your attacks leave lingering echoes of shadow. These echoes confuse enemies, causing them to strike illusions or hesitate, giving you more control in battle.';
		}
	},
	'Midnight Crescendo': {
		points: 0,
		max: 5,
		tree: 'The Symphony of Shadows',
		descriptionFn: function descriptionFn(p, d) {
			return 'For a short duration, become one with the darkness. Your attacks ignore some armor, movement speed increases, and enemies are overwhelmed by disorienting echoes. A swirling concert of shadows amplifies your lethality.';
		}
	}
};
// --- Centralized Skill Tree Layout Data ---
// This structure holds the background image, list of skills (nodes),
// node positions, and the mapping of skill names to their icon asset names for each tree.
var skillTreeLayouts = {
	'The Circuit of Ascension': {
		backgroundAsset: 'popup_circuitofascension',
		nodes: ['Data Spike', 'Reflex Accelerator', 'Overclock Core', 'Neural Hijack', 'Dodge Matrix', 'Power Surge', 'Overload Blast'],
		positions: {
			// Positions from original code
			'Data Spike': {
				x: 2048 / 4 - 50,
				y: 2732 / 6 - 50 + 100
			},
			'Reflex Accelerator': {
				x: 2048 / 2,
				y: 2732 / 6 - 50 + 100
			},
			'Overclock Core': {
				x: 3 * 2048 / 4 + 50,
				y: 2732 / 6 - 50 + 100
			},
			'Neural Hijack': {
				x: 2048 / 4 - 50,
				y: 2 * 2732 / 6 + 100
			},
			'Dodge Matrix': {
				x: 2048 / 2,
				y: 2 * 2732 / 6 + 100
			},
			'Power Surge': {
				x: 3 * 2048 / 4 + 50,
				y: 2 * 2732 / 6 + 100
			},
			'Overload Blast': {
				x: 2048 / 2,
				y: 3 * 2732 / 6 + 50 + 100
			}
		},
		icons: {
			// *** Replace these values with your actual asset names defined in LK.init.image *** 
			'Data Spike': 'Data Spike_icon',
			'Reflex Accelerator': 'Reflex Accelerator_icon',
			'Overclock Core': 'Overclock Core_icon',
			'Neural Hijack': 'Neural Hijack_icon',
			'Dodge Matrix': 'Dodge Matrix_icon',
			'Power Surge': 'Power Surge_icon',
			'Overload Blast': 'Overload Blast_icon'
		}
	},
	'The Echoes of Ancestry': {
		backgroundAsset: 'popup_echoesofancestry',
		nodes: ['Ancient Wisdom', 'Elemental Mastery', 'Warrior Spirit', 'Beast Tamer', 'Herbal Remedies', 'Spirit Guidance', 'Legendary Ancestor'],
		positions: {
			// Positions from original code
			'Ancient Wisdom': {
				x: 2048 / 4 - 50,
				y: 2732 / 6 - 50 + 100
			},
			'Elemental Mastery': {
				x: 2048 / 2,
				y: 2732 / 6 - 50 + 100
			},
			'Warrior Spirit': {
				x: 3 * 2048 / 4 + 50,
				y: 2732 / 6 - 50 + 100
			},
			'Beast Tamer': {
				x: 2048 / 4 - 50,
				y: 2 * 2732 / 6 + 100
			},
			'Herbal Remedies': {
				x: 2048 / 2,
				y: 2 * 2732 / 6 + 100
			},
			'Spirit Guidance': {
				x: 3 * 2048 / 4 + 50,
				y: 2 * 2732 / 6 + 100
			},
			'Legendary Ancestor': {
				x: 2048 / 2,
				y: 3 * 2732 / 6 + 50 + 100
			}
		},
		icons: {
			// *** Replace these values with your actual asset names defined in LK.init.image *** 
			'Ancient Wisdom': 'Ancient Wisdom_icon',
			'Elemental Mastery': 'Elemental Mastery_icon',
			'Warrior Spirit': 'Warrior Spirit_icon',
			'Beast Tamer': 'Beast Tamer_icon',
			'Herbal Remedies': 'Herbal Remedies_icon',
			'Spirit Guidance': 'Spirit Guidance_icon',
			'Legendary Ancestor': 'Legendary Ancestor_icon'
		}
	},
	'The Forge of Possibilities': {
		backgroundAsset: 'popup_forgeofpossibilities',
		nodes: ['Adaptive Construction', 'Elemental Infusion', 'Modular Enhancement', 'Resourceful Salvage', 'Hybrid Crafting', 'Runic Slots', 'Masterwork Creation'],
		positions: {
			// Positions from original code
			'Adaptive Construction': {
				x: 2048 / 4 - 50,
				y: 2732 / 6 - 50 + 100
			},
			'Elemental Infusion': {
				x: 2048 / 2,
				y: 2732 / 6 - 50 + 100
			},
			'Modular Enhancement': {
				x: 3 * 2048 / 4 + 50,
				y: 2732 / 6 - 50 + 100
			},
			'Resourceful Salvage': {
				x: 2048 / 4 - 50,
				y: 2 * 2732 / 6 + 100
			},
			'Hybrid Crafting': {
				x: 2048 / 2,
				y: 2 * 2732 / 6 + 100
			},
			'Runic Slots': {
				x: 3 * 2048 / 4 + 50,
				y: 2 * 2732 / 6 + 100
			},
			'Masterwork Creation': {
				x: 2048 / 2,
				y: 3 * 2732 / 6 + 50 + 100
			}
		},
		icons: {
			// *** Replace these values with your actual asset names defined in LK.init.image *** 
			'Adaptive Construction': 'Adaptive Construction_icon',
			'Elemental Infusion': 'Elemental Infusion_icon',
			'Modular Enhancement': 'Modular Enhancement_icon',
			'Resourceful Salvage': 'Resourceful Salvage_icon',
			'Hybrid Crafting': 'Hybrid Crafting_icon',
			'Runic Slots': 'Runic Slots_icon',
			'Masterwork Creation': 'Masterwork Creation_icon'
		}
	},
	'The Prism of Potential': {
		backgroundAsset: 'popup_prismofpotential',
		nodes: ['Red Radiance', 'Blue Bulwark', 'Green Growth', 'Yellow Zephyr', 'Indigo Insight', 'Chromatic Fusion', 'Prismatic Ascendance'],
		positions: {
			// Positions from original code
			'Red Radiance': {
				x: 2048 / 4 - 50,
				y: 2732 / 6 - 50 + 100
			},
			'Blue Bulwark': {
				x: 2048 / 2,
				y: 2732 / 6 - 50 + 100
			},
			'Green Growth': {
				x: 3 * 2048 / 4 + 50,
				y: 2732 / 6 - 50 + 100
			},
			'Yellow Zephyr': {
				x: 2048 / 4 - 50,
				y: 2 * 2732 / 6 + 100
			},
			'Indigo Insight': {
				x: 2048 / 2,
				y: 2 * 2732 / 6 + 100
			},
			'Chromatic Fusion': {
				x: 3 * 2048 / 4 + 50,
				y: 2 * 2732 / 6 + 100
			},
			'Prismatic Ascendance': {
				x: 2048 / 2,
				y: 3 * 2732 / 6 + 50 + 100
			}
		},
		icons: {
			// *** Replace these values with your actual asset names defined in LK.init.image *** 
			'Red Radiance': 'Red Radiance_icon',
			'Blue Bulwark': 'Blue Bulwark_icon',
			'Green Growth': 'Green Growth_icon',
			'Yellow Zephyr': 'Yellow Zephyr_icon',
			'Indigo Insight': 'Indigo Insight_icon',
			'Chromatic Fusion': 'Chromatic Fusion_icon',
			'Prismatic Ascendance': 'Prismatic Ascendance_icon'
		}
	},
	'The Nexus of Chaos': {
		backgroundAsset: 'popup_nexusofchaos',
		nodes: ['Chaotic Spark', 'Entropy Shield', 'Unstable Rift', 'Anomaly Shift', 'Cascade of Disorder', 'Fractured Fate', 'Reality Collapse'],
		positions: {
			// Positions from original code
			'Chaotic Spark': {
				x: 2048 / 4 - 50,
				y: 2732 / 6 - 50 + 100
			},
			'Entropy Shield': {
				x: 2048 / 2,
				y: 2732 / 6 - 50 + 100
			},
			'Unstable Rift': {
				x: 3 * 2048 / 4 + 50,
				y: 2732 / 6 - 50 + 100
			},
			'Anomaly Shift': {
				x: 2048 / 4 - 50,
				y: 2 * 2732 / 6 + 100
			},
			'Cascade of Disorder': {
				x: 2048 / 2,
				y: 2 * 2732 / 6 + 100
			},
			'Fractured Fate': {
				x: 3 * 2048 / 4 + 50,
				y: 2 * 2732 / 6 + 100
			},
			'Reality Collapse': {
				x: 2048 / 2,
				y: 3 * 2732 / 6 + 50 + 100
			}
		},
		icons: {
			// *** Replace these values with your actual asset names defined in LK.init.image *** 
			'Chaotic Spark': 'Chaotic Spark_icon',
			'Entropy Shield': 'Entropy Shield_icon',
			'Unstable Rift': 'Unstable Rift_icon',
			'Anomaly Shift': 'Anomaly Shift_icon',
			'Cascade of Disorder': 'Cascade of Disorder_icon',
			'Fractured Fate': 'Fractured Fate_icon',
			'Reality Collapse': 'Reality Collapse_icon'
		}
	},
	'The Symphony of Shadows': {
		backgroundAsset: 'popup_symphonyofshadows',
		nodes: ['Whispered Steps', 'Nightfall Veil', 'Serrated Shade', 'Shadow Familiar', 'Muffled Strikes', 'Umbral Echoes', 'Midnight Crescendo'],
		positions: {
			// Positions from original code
			'Whispered Steps': {
				x: 2048 / 4 - 50,
				y: 2732 / 6 - 50 + 100
			},
			'Nightfall Veil': {
				x: 2048 / 2,
				y: 2732 / 6 - 50 + 100
			},
			'Serrated Shade': {
				x: 3 * 2048 / 4 + 50,
				y: 2732 / 6 - 50 + 100
			},
			'Shadow Familiar': {
				x: 2048 / 4 - 50,
				y: 2 * 2732 / 6 + 100
			},
			'Muffled Strikes': {
				x: 2048 / 2,
				y: 2 * 2732 / 6 + 100
			},
			'Umbral Echoes': {
				x: 3 * 2048 / 4 + 50,
				y: 2 * 2732 / 6 + 100
			},
			'Midnight Crescendo': {
				x: 2048 / 2,
				y: 3 * 2732 / 6 + 50 + 100
			}
		},
		icons: {
			// *** Replace these values with your actual asset names defined in LK.init.image *** 
			'Whispered Steps': 'Whispered Steps_icon',
			'Nightfall Veil': 'Nightfall Veil_icon',
			'Serrated Shade': 'Serrated Shade_icon',
			'Shadow Familiar': 'Shadow Familiar_icon',
			'Muffled Strikes': 'Muffled Strikes_icon',
			'Umbral Echoes': 'Umbral Echoes_icon',
			'Midnight Crescendo': 'Midnight Crescendo_icon'
		}
	}
};
/**** 
* Global Variables (Gameplay State)
****/ 
var arrows = [];
var currentRoom;
var visitedRooms = [];
var currentRoomMusic = null; // Reference to currently playing music instance (if needed for stopping)
var hero;
var isPopupActive = false; // General flag for any major popup (main skill tree, specific tree)
var isSkillDetailPopupActive = false; // Specific flag for the skill *detail* popup
var gameContainer = new Container();
var uiContainer = new Container();
var menuContainer = new Container(); // Holds main skill tree, specific trees, and detail popups
// UI Element References (initialized later)
var skillTreePopup = null; // Main selection screen
var skillPointsDisplay = null; // Text on main selection screen
var skillTreePointsText = null; // Text on individual tree screens
var roomDisplay = null;
var healthText = null;
game.addChild(gameContainer); // For gameplay elements (hero, enemies, projectiles)
game.addChild(uiContainer); // For UI elements (joysticks, buttons not part of popups)
game.addChild(menuContainer); // For popups (skill tree, skill details)
/**** 
* Helper Functions & Game Logic
****/ 
// --- Skill System Functions ---
// Creates the popup container for skill details
function createSkillPopup(skillTitle, skillDescription) {
	var skillPopup = new Container();
	skillPopup.width = roomWidth;
	skillPopup.height = roomHeight;
	skillPopup.interactive = true; // Prevent clicks going through
	var skillData = skillDefinitions[skillTitle]; // Get skill data
	// Translucent Background
	var translucentBackground = LK.getAsset('box', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: roomWidth,
		height: roomHeight,
		color: 0x000000,
		alpha: 0.7
	});
	translucentBackground.x = roomWidth / 2;
	translucentBackground.y = roomHeight / 2;
	skillPopup.addChild(translucentBackground);
	// Title Text
	var skillTitleText = new Text2(skillTitle, {
		size: 120,
		fill: 0xFFFFFF,
		fontWeight: "bold",
		fontFamily: "Techno, sans-serif",
		letterSpacing: 2,
		stroke: 0x00FFCC,
		strokeThickness: 3,
		align: 'center'
	});
	skillTitleText.x = roomWidth / 2;
	skillTitleText.y = roomHeight / 2 - 600; // Position higher up
	skillTitleText.anchor.set(0.5, 0.5);
	skillPopup.addChild(skillTitleText);
	// Description Text (Give it a name)
	var skillDescriptionText = new Text2(skillDescription, {
		size: 70,
		fill: 0xFFFFFF,
		fontFamily: "Arial, sans-serif",
		letterSpacing: 1,
		stroke: 0x00FFCC,
		strokeThickness: 2,
		wordWrap: true,
		wordWrapWidth: 1800,
		align: 'center'
	});
	skillDescriptionText.x = roomWidth / 2;
	skillDescriptionText.y = skillTitleText.y + 300; // Position below title
	skillDescriptionText.anchor.set(0.5, 0.5);
	skillDescriptionText.name = "skillDescriptionText"; // Name for updating
	skillPopup.addChild(skillDescriptionText);
	// Add helper method to find children by name
	skillPopup.getChildByName = function (name) {
		for (var i = 0; i < this.children.length; i++) {
			if (this.children[i].name === name) {
				return this.children[i];
			}
		}
		return null;
	};
	// Allocation Text (Give it a name)
	if (skillData) {
		var points = skillData.points;
		var maxPoints = skillData.max;
		var allocationText = new Text2(points + '/' + maxPoints, {
			size: 80,
			fill: 0xFFFFFF,
			fontWeight: "bold",
			stroke: 0x00FFCC,
			strokeThickness: 2
		});
		allocationText.x = roomWidth / 2;
		allocationText.y = skillDescriptionText.y + skillDescriptionText.height / 2 + 100; // Below description
		allocationText.anchor.set(0.5, 0.5);
		allocationText.name = "allocationText"; // Name for updating
		skillPopup.addChild(allocationText);
	}
	// --- Buttons ---
	var buttonY = roomHeight / 2 + 450; // Position buttons lower
	// Exit Button
	var exitButton = LK.getAsset('cancelButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 3,
		scaleY: 3
	});
	exitButton.x = roomWidth / 2 - 400; // Spread buttons
	exitButton.y = buttonY;
	exitButton.down = function () {
		menuContainer.removeChild(skillPopup);
		isSkillDetailPopupActive = false; // Reset the specific flag
		updateSkillNodePointDisplays(); // Update points on the tree screen when closing
	};
	skillPopup.addChild(exitButton);
	// --- Modified Spend Button ---
	var spendButton = LK.getAsset('spendButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 3,
		scaleY: 3
	});
	spendButton.x = roomWidth / 2 + 400; // Spread buttons
	spendButton.y = buttonY; // Use the calculated button Y position
	spendButton.down = function () {
		// ** Check skillData exists first **
		if (!skillData) {
			return;
		}
		if (heroSkillPoints > 0 && skillData.points < skillData.max) {
			heroSkillPoints--;
			skillData.points++; // Update points in central definition
			// Refresh global skill point displays
			refreshSkillPointsText(); // Updates display on popup and underlying screens
			// --- Update EXISTING popup content using direct variables ---
			// ** No need for getChildByName **
			// Update Description Text
			if (skillDescriptionText && skillData.descriptionFn) {
				// Use skillDescriptionText directly
				// Regenerate description with new point count
				var newDescription = skillData.descriptionFn(skillData.points, skillData.calcData);
				skillDescriptionText.setText(newDescription); // Update the text
				// Adjust allocation text position relative to potentially resized description
				if (allocationText) {
					// Check if allocationText exists before accessing its y property
					allocationText.y = skillDescriptionText.y + skillDescriptionText.height / 2 + 100;
				}
			}
			// Update Allocation Text
			if (allocationText) {
				// Use allocationText directly
				allocationText.setText(skillData.points + '/' + skillData.max);
			}
			// --- End Update EXISTING popup content ---
			// Update the points on the node behind this popup immediately
			updateSkillNodePointDisplays();
		} else {
			// Add visual feedback? (e.g., shake button, change color briefly)
		}
	};
	skillPopup.addChild(spendButton);
	// Skill Points Text (for this popup) - Ensure it gets updated
	var skillPointsTextPopup = new Text2('Skill Points: ' + heroSkillPoints, {
		size: 70,
		fill: 0xFFFFFF,
		fontWeight: "bold"
	});
	skillPointsTextPopup.x = roomWidth / 2;
	skillPointsTextPopup.y = roomHeight - 100; // bottom area of popup
	skillPointsTextPopup.anchor.set(0.5, 1); // Anchor at bottom center
	skillPointsTextPopup.name = "popupSkillPointsText"; // Name it
	skillPopup.addChild(skillPointsTextPopup);
	return skillPopup;
}
// Displays the details for a specific skill (Called by node clicks)
function displaySkillDetailPopup(skillName) {
	if (isSkillDetailPopupActive) {
		return;
	} // Prevent multiple detail popups
	var skillData = skillDefinitions[skillName];
	if (!skillData) {
		return;
	}
	var currentPoints = skillData.points;
	var description = skillData.descriptionFn ? skillData.descriptionFn(currentPoints, skillData.calcData) : "No description available.";
	var skillPopup = createSkillPopup(skillName, description);
	menuContainer.addChild(skillPopup);
	isSkillDetailPopupActive = true; // Set the specific flag
	isPopupActive = false; // Ensure general flag is off if only detail popup is shown
}
// Creates a single node in the skill tree view (Modified for unique icons)
function createSkillTreeNode(skillName, position, parentPopup) {
	var skillData = skillDefinitions[skillName];
	if (!skillData) {
		return;
	}
	// --- Get Specific Icon Asset Name ---
	var iconAssetId = 'skill_node_placeholder'; // Default to placeholder
	var treeLayout = skillTreeLayouts[skillData.tree];
	if (treeLayout && treeLayout.icons && treeLayout.icons[skillName]) {
		iconAssetId = treeLayout.icons[skillName]; // Use specific asset name if mapped
	} else {
		// Optional: Log a warning if a specific icon mapping is missing
		// console.log("Warning: Icon asset mapping missing for skill: " + skillName);
	}
	// --- Create Node Graphic ---
	var skillNodeGraphic = null;
	try {
		skillNodeGraphic = LK.getAsset(iconAssetId, {
			anchorX: 0.5,
			// Set anchor in asset definition or here if needed
			anchorY: 0.5
			// width: 80, height: 80 // Set size in asset definition preferably
		});
	} catch (e) {
		// Fallback if the specific asset failed to load (e.g., not defined yet)
		console.log("Error loading asset '" + iconAssetId + "', using placeholder. Error: " + e);
		iconAssetId = 'skill_node_placeholder'; // Ensure we use placeholder name
		skillNodeGraphic = LK.getAsset(iconAssetId, {
			anchorX: 0.5,
			anchorY: 0.5
			// width: 80, height: 80 // Defined in placeholder asset
		});
	}
	skillNodeGraphic.x = position.x;
	skillNodeGraphic.y = position.y;
	skillNodeGraphic.interactive = true;
	// --- Points Text ---
	var points = skillData.points;
	var maxPoints = skillData.max;
	var pointsText = new Text2(points + '/' + maxPoints, {
		size: 40,
		fill: 0xFFFFFF,
		fontWeight: "bold",
		// Slightly smaller text
		stroke: 0x000000,
		strokeThickness: 3 // Thinner stroke maybe
	});
	pointsText.x = position.x;
	// Adjust Y offset based on your icon size (assuming icon is anchored center)
	// If your icons are ~80px tall, offset by slightly more than half height
	pointsText.y = position.y + 50; // Adjust this value as needed
	pointsText.anchor.set(0.5, 0); // Anchor horizontal center, vertical top
	pointsText.name = skillName + "_pointsText"; // Unique name for updates
	// --- Click Handler ---
	skillNodeGraphic.down = function () {
		displaySkillDetailPopup(skillName); // Call the single generic display function
		// Visual feedback (Flash) - Optional
		var originalTint = skillNodeGraphic.tint !== undefined ? skillNodeGraphic.tint : null;
		skillNodeGraphic.tint = 0xFFFF00; // Yellow flash
		LK.setTimeout(function () {
			if (skillNodeGraphic.tint !== undefined) {
				skillNodeGraphic.tint = originalTint;
			}
		}, 150);
	};
	parentPopup.addChild(skillNodeGraphic);
	parentPopup.addChild(pointsText);
}
// Opens the specific skill tree view popup
function openSkillTreePopup(skillTreeName) {
	menuContainer.removeChild(skillTreePopup); // Remove main selection screen
	var layoutData = skillTreeLayouts[skillTreeName];
	if (!layoutData) {
		menuContainer.addChild(skillTreePopup); // Go back to main selection
		return;
	}
	var newPopup = new Container();
	newPopup.width = roomWidth;
	newPopup.height = roomHeight;
	newPopup.interactive = true; // Block clicks through
	newPopup.name = skillTreeName + "_popup"; // Name the popup
	// Background
	var newPopupBackground = LK.getAsset(layoutData.backgroundAsset, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	newPopupBackground.x = roomWidth / 2;
	newPopupBackground.y = roomHeight / 2;
	newPopup.addChild(newPopupBackground);
	// Back Button (Use the class)
	var backButton = new BackButton();
	newPopup.addChild(backButton);
	// Title (Modified for better centering and wrapping)
	var skillTreeTitle = new Text2(skillTreeName, {
		size: 100,
		fill: 0xFFFFFF,
		fontWeight: "bold",
		fontFamily: "Techno, sans-serif",
		letterSpacing: 2,
		stroke: 0x00FFCC,
		strokeThickness: 3,
		align: 'center',
		// Explicitly center align the text
		wordWrap: true,
		// Enable word wrap
		wordWrapWidth: roomWidth * 0.8 // Wrap if title exceeds 80% of screen width
	});
	skillTreeTitle.x = roomWidth / 2; // Center horizontally
	skillTreeTitle.y = 100; // Position near top
	skillTreeTitle.anchor.set(0.5, 0); // Anchor at horizontal center, vertical top
	newPopup.addChild(skillTreeTitle);
	// Create Nodes
	layoutData.nodes.forEach(function (skillName) {
		var position = layoutData.positions[skillName];
		if (position) {
			createSkillTreeNode(skillName, position, newPopup);
		} else {}
	});
	// Skill Points Display at Bottom (use global reference)
	skillTreePointsText = new Text2('Skill Points: ' + heroSkillPoints, {
		size: 70,
		fill: 0xFFFFFF,
		fontWeight: "bold"
	});
	skillTreePointsText.x = roomWidth / 2;
	skillTreePointsText.y = roomHeight - 100; // bottom of the screen
	skillTreePointsText.anchor.set(0.5, 1); // Anchor bottom center
	newPopup.addChild(skillTreePointsText);
	refreshTreePointsText(); // Update the text content
	menuContainer.addChild(newPopup);
	isPopupActive = true; // This tree view is a major popup
	isSkillDetailPopupActive = false; // Detail view is not open yet
}
// Refreshes the skill points text on visible UI elements
function refreshSkillPointsText() {
	// Update main skill tree selection screen text (if visible)
	if (skillPointsDisplay && skillPointsDisplay.parent) {
		skillPointsDisplay.setText('Skill Points: ' + heroSkillPoints);
	}
	// Update individual skill tree screen text (if visible)
	if (skillTreePointsText && skillTreePointsText.parent) {
		skillTreePointsText.setText('Skill Points: ' + heroSkillPoints);
	}
	// Update skill detail popup text (if visible and active)
	if (isSkillDetailPopupActive && menuContainer.children.length > 0) {
		var currentPopup = menuContainer.children[menuContainer.children.length - 1];
		// Check if it's likely the detail popup (has the specific text element)
		var popupPointsText = currentPopup.getChildByName ? currentPopup.getChildByName("popupSkillPointsText") : null;
		if (popupPointsText) {
			popupPointsText.setText('Skill Points: ' + heroSkillPoints);
		}
	}
}
// Updates the 'X/Y' text on the nodes within an active skill tree popup
function updateSkillNodePointDisplays() {
	var activeSkillTreePopup = null;
	// Find the currently displayed skill tree popup by its name convention
	for (var i = menuContainer.children.length - 1; i >= 0; i--) {
		var child = menuContainer.children[i];
		// Check if child has a name and it ends with '_popup' (set in openSkillTreePopup)
		if (child && child.name && child.name.endsWith("_popup")) {
			activeSkillTreePopup = child;
			break; // Found the active tree popup
		}
	}
	// Only proceed if we found an active skill tree popup
	if (activeSkillTreePopup && activeSkillTreePopup.children) {
		// Check children array exists
		// Loop through all skills defined in our central structure
		for (var skillName in skillDefinitions) {
			if (skillDefinitions.hasOwnProperty(skillName)) {
				var skillData = skillDefinitions[skillName];
				var targetNodeName = skillName + "_pointsText"; // The name of the text node we are looking for
				// Iterate through the children of the active skill tree popup to find the node
				var foundNode = false; // Flag to stop searching once found
				for (var k = 0; k < activeSkillTreePopup.children.length; k++) {
					var nodeChild = activeSkillTreePopup.children[k];
					// Check if this child is the points text node we want by name
					if (nodeChild && nodeChild.name === targetNodeName) {
						// Found it! Update the text.
						// Make sure it's a text object with setText
						if (nodeChild.setText) {
							nodeChild.setText(skillData.points + '/' + skillData.max);
						} else {}
						foundNode = true; // Mark as found
						break; // Stop searching children for this specific skillName
					}
				} // End inner loop (children iteration)
			}
		} // End outer loop (skillDefinitions iteration)
	} else {
		// This case means no skill tree popup is currently active, which is normal
		// when the player is in the game or on the main skill selection screen.
	}
}
// Refreshes the skill points text specifically on the individual tree view (if open)
function refreshTreePointsText() {
	if (skillTreePointsText && skillTreePointsText.parent) {
		// Check if it exists and is on stage
		skillTreePointsText.setText('Skill Points: ' + heroSkillPoints);
	}
}
// --- Room and Game Flow Functions ---
function addDirectionalArrows() {
	// Remove existing arrows first to prevent duplicates
	gameContainer.children.forEach(function (child) {
		if (child.isDirectionalArrow) {
			// Add a flag to identify these arrows
			gameContainer.removeChild(child);
		}
	});
	var arrowDirections = ['top', 'bottom', 'left', 'right'];
	arrowDirections.forEach(function (direction) {
		var arrow = LK.getAsset('directionalArrow', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		arrow.isDirectionalArrow = true; // Add flag
		switch (direction) {
			case 'top':
				arrow.x = roomWidth / 2;
				arrow.y = wallThickness + 150;
				arrow.rotation = 0;
				break;
			case 'bottom':
				arrow.x = roomWidth / 2;
				arrow.y = roomHeight - wallThickness - 150;
				arrow.rotation = Math.PI;
				break;
			case 'left':
				arrow.x = wallThickness + 150;
				arrow.y = roomHeight / 2;
				arrow.rotation = -Math.PI / 2;
				break;
			case 'right':
				arrow.x = roomWidth - wallThickness - 150;
				arrow.y = roomHeight / 2;
				arrow.rotation = Math.PI / 2;
				break;
		}
		gameContainer.addChild(arrow); // Add arrows to game container, not UI
		LK.effects.flashObject(arrow, 0xffffff, 1000); // Flash effect
	});
}
function removeDirectionalArrows() {
	gameContainer.children.slice().forEach(function (child) {
		// Iterate over a copy
		if (child.isDirectionalArrow) {
			gameContainer.removeChild(child);
		}
	});
}
function updateRoomDisplay() {
	if (!roomDisplay || !currentRoom || !hero) {
		return;
	} // Ensure UI elements and game state exist
	var enemiesLeft = currentRoom.killGoal - currentRoom.enemiesKilled;
	roomDisplay.setText('Room: ' + currentRoom.number + ' | Enemies Left: ' + Math.max(enemiesLeft, 0));
	if (healthText) {
		healthText.setText('Health: ' + Math.max(hero.health, 0));
	} // Show 0 if health < 0
}
function stopRoomMusic() {
	LK.stopMusic(); // Use engine's function to stop all music
	currentRoomMusic = null;
}
function playRoomMusic(roomNumber) {
	stopRoomMusic(); // Stop previous music first
	var musicAsset = 'room' + roomNumber + '_music';
	// Check if asset exists? LK might handle errors gracefully or not.
	try {
		currentRoomMusic = LK.playMusic(musicAsset, {
			loop: true
		}); // Play new music
	} catch (e) {}
}
function checkRoomCleared() {
	if (!currentRoom || currentRoom.isCleared) {
		return;
	}
	if (currentRoom.enemiesKilled >= currentRoom.killGoal) {
		currentRoom.isCleared = true;
		hero.canExitRoom = true; // Allow hero to leave
		// Play room cleared sound
		var soundAsset = 'room' + currentRoom.number + '_cleared';
		try {
			var roomClearedSound = LK.getSound(soundAsset); // Get sound object
			if (roomClearedSound && roomClearedSound.play) {
				roomClearedSound.play();
			}
		} catch (e) {}
		stopRoomMusic(); // Stop the room's music
		updateRoomDisplay();
		addDirectionalArrows(); // Show exits
	}
}
function transitionToNextRoom() {
	// --- Clean up current room ---
	if (game.background) {
		game.removeChild(game.background);
		game.background = null;
	}
	// Clear remaining enemies explicitly
	currentRoom.enemies.slice().forEach(function (enemy) {
		// Iterate over a copy
		if (enemy.parent) {
			enemy.parent.removeChild(enemy);
		}
		// if(enemy.destroy) enemy.destroy(); // Use engine destroy if available
	});
	currentRoom.enemies = [];
	removeDirectionalArrows(); // Remove exit indicators
	// --- Choose next room ---
	if (!visitedRooms.includes(currentRoom.number)) {
		visitedRooms.push(currentRoom.number);
	}
	if (visitedRooms.length >= totalRooms) {
		visitedRooms = []; // Reset if all rooms visited
		// Optionally exclude the immediate previous room
		if (currentRoom) {
			visitedRooms.push(currentRoom.number);
		}
	}
	var nextRoomNumber;
	do {
		nextRoomNumber = Math.floor(Math.random() * totalRooms) + 1;
	} while (visitedRooms.includes(nextRoomNumber)); // Ensure it's not in the visited list for this cycle
	// --- Initialize the new room ---
	currentRoom = new Room(nextRoomNumber); // Create new Room object
	// Set up background
	var bgImageIndex = (currentRoom.number - 1) % roomBackgroundImages.length;
	var bgImage = LK.getAsset(roomBackgroundImages[bgImageIndex], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bgImage.x = roomWidth / 2;
	bgImage.y = roomHeight / 2;
	game.addChildAt(bgImage, 0); // Add background behind other game elements
	game.background = bgImage;
	// Update UI and state
	hero.canExitRoom = false;
	updateRoomDisplay();
	playRoomMusic(currentRoom.number);
	currentRoom.startSpawning(); // Start spawning enemies for the new room
}
// Called by Hero when entering an exit zone
function transitionToNewRoom(entrySide) {
	// Position hero based on where they will ENTER the NEW room
	if (entrySide === 'top') {
		hero.y = wallThickness + hero.height / 2 + 10;
		hero.x = roomWidth / 2;
	} else if (entrySide === 'bottom') {
		hero.y = roomHeight - wallThickness - hero.height / 2 - 10;
		hero.x = roomWidth / 2;
	} else if (entrySide === 'left') {
		hero.x = wallThickness + hero.width / 2 + 10;
		hero.y = roomHeight / 2;
	} else if (entrySide === 'right') {
		hero.x = roomWidth - wallThickness - hero.width / 2 - 10;
		hero.y = roomHeight / 2;
	}
	stopRoomMusic(); // Stop music before transition logic
	transitionToNextRoom(); // Sets up the new room, plays music, etc.
}
// --- Room Class Definition ---
var Room = function Room(number) {
	this.number = number;
	this.enemies = [];
	this.isCleared = false;
	// Adjust spawn counts/kill goals as needed
	this.spawnLimit = this.number === 1 ? 15 : 10 + 5 * this.number; // Example scaling
	this.killGoal = this.spawnLimit;
	this.enemiesSpawned = 0;
	this.enemiesKilled = 0;
	this.enemyCounter = 0; // Count of currently active enemies
	this.spawnIntervalId = null; // To store the interval ID
	this.startSpawning = function () {
		var self = this; // Reference to 'this' room instance
		var spawnDelay = 1500; // ms between spawns
		this.spawnIntervalId = LK.setInterval(function () {
			// Check conditions *inside* the interval function
			if (self.enemiesSpawned < self.spawnLimit && !self.isCleared && !isPopupActive && !isSkillDetailPopupActive) {
				self.spawnEnemy();
			} else if (self.enemiesSpawned >= self.spawnLimit || self.isCleared) {
				// Stop spawning if limit reached or room cleared
				LK.clearInterval(self.spawnIntervalId);
				self.spawnIntervalId = null;
			}
			// If popups are active, the interval continues but doesn't spawn
		}, spawnDelay);
	};
	this.spawnEnemy = function () {
		// Double check conditions just before spawning
		if (this.enemiesSpawned >= this.spawnLimit || this.isCleared || isPopupActive || isSkillDetailPopupActive) {
			return;
		}
		var spawnKeys = Object.keys(spawnPoints);
		var spawnIndex = Math.floor(Math.random() * spawnKeys.length);
		var spawnPoint = spawnPoints[spawnKeys[spawnIndex]];
		var enemy = null;
		var enemyTypeRand = Math.random();
		// Define spawn probabilities based on room number
		if (this.number <= 1) {
			// Room 1: Mostly basic, few tanks
			if (enemyTypeRand < 0.15) {
				enemy = new TankEnemy();
			} // 15% Tank
			else {
				enemy = new Enemy();
			} // 85% Basic
		} else if (this.number <= 3) {
			// Rooms 2-3: Introduce ranged
			if (enemyTypeRand < 0.15) {
				enemy = new TankEnemy();
			} // 15% Tank
			else if (enemyTypeRand < 0.40) {
				enemy = new RangedEnemy();
			} // 25% Ranged
			else {
				enemy = new Enemy();
			} // 60% Basic
		} else {
			// Rooms 4+: More tough enemies
			if (enemyTypeRand < 0.25) {
				enemy = new TankEnemy();
			} // 25% Tank
			else if (enemyTypeRand < 0.60) {
				enemy = new RangedEnemy();
			} // 35% Ranged
			else {
				enemy = new Enemy();
			} // 40% Basic
		}
		if (enemy) {
			enemy.x = spawnPoint.x;
			enemy.y = spawnPoint.y;
			// enemy.active = true; // Set in BaseEnemy constructor/init
			// enemy.health = ???; // Set in specific enemy class constructor
			enemy.visible = true;
			this.enemies.push(enemy);
			gameContainer.addChild(enemy); // Add to the game world container
			this.enemiesSpawned++;
			this.enemyCounter++; // Increment active enemy count
		}
	};
	// Call startSpawning when the room is created and ready
	// this.startSpawning(); // Moved initialization to transitionToNextRoom
};
/**** 
* Game Setup and Initialization
****/ 
function initializeMainMenu() {
	// Create the main skill tree selection popup container
	skillTreePopup = new Container();
	skillTreePopup.width = roomWidth;
	skillTreePopup.height = roomHeight;
	skillTreePopup.interactive = true;
	var skillTreeBackground = LK.getAsset('skillTree_Background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	skillTreeBackground.x = roomWidth / 2;
	skillTreeBackground.y = roomHeight / 2;
	skillTreePopup.addChild(skillTreeBackground);
	// Skill Points Display for main menu
	skillPointsDisplay = new Text2('Skill Points: ' + heroSkillPoints, {
		size: 70,
		fill: 0xFFFFFF,
		fontWeight: "bold"
	});
	skillPointsDisplay.x = roomWidth / 2;
	skillPointsDisplay.y = roomHeight - 100; // Near bottom
	skillPointsDisplay.anchor.set(0.5, 1); // Anchor bottom center
	skillTreePopup.addChild(skillPointsDisplay);
	// Define positions for the 6 main tree icons/titles
	var treeIconPositions = [{
		x: roomWidth / 2 - 450,
		y: roomHeight / 2 - 550
	}, {
		x: roomWidth / 2 + 450,
		y: roomHeight / 2 - 550
	}, {
		x: roomWidth / 2 - 450,
		y: roomHeight / 2
	}, {
		x: roomWidth / 2 + 450,
		y: roomHeight / 2
	}, {
		x: roomWidth / 2 - 450,
		y: roomHeight / 2 + 550
	}, {
		x: roomWidth / 2 + 450,
		y: roomHeight / 2 + 550
	}];
	var skillTreeAssetMap = {
		'The Circuit of Ascension': 'circuitofascension',
		'The Echoes of Ancestry': 'echoesofancestry',
		'The Forge of Possibilities': 'forgeofpossibilities',
		'The Prism of Potential': 'prismofpotential',
		'The Nexus of Chaos': 'nexusofchaos',
		'The Symphony of Shadows': 'symphonyofshadows'
	};
	var skillTreeTitles = Object.keys(skillTreeAssetMap);
	skillTreeTitles.forEach(function (title, index) {
		if (index >= treeIconPositions.length) {
			return;
		} // Safety check
		var position = treeIconPositions[index];
		var assetId = skillTreeAssetMap[title];
		// Title Text
		var titleText = new Text2(title, {
			size: 40,
			fill: 0xFFFFFF,
			fontWeight: "bold",
			// Smaller title
			fontFamily: "Techno, sans-serif",
			letterSpacing: 1,
			stroke: 0x00FFCC,
			strokeThickness: 2,
			align: 'center',
			wordWrap: true,
			wordWrapWidth: 300
		});
		titleText.x = position.x;
		titleText.y = position.y + 200; // Below icon
		titleText.anchor.set(0.5, 0);
		// Icon Asset
		var skillTreeAsset = LK.getAsset(assetId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		skillTreeAsset.x = position.x;
		skillTreeAsset.y = position.y;
		skillTreeAsset.interactive = true;
		// Click handler for icon AND title
		var clickHandler = function clickHandler() {
			openSkillTreePopup(title);
		};
		skillTreeAsset.down = clickHandler;
		titleText.interactive = true;
		titleText.down = clickHandler;
		skillTreePopup.addChild(skillTreeAsset);
		skillTreePopup.addChild(titleText);
	});
	// Start Game Button
	var startGameButton = new StartGameButton();
	skillTreePopup.addChild(startGameButton);
	// Add the main menu to the stage
	menuContainer.addChild(skillTreePopup);
	isPopupActive = true; // Start with the menu active
}
function initializeGame() {
	// Initial setup when the game actually begins playing
	// Create Hero if not already created
	if (!hero) {
		hero = gameContainer.addChild(new Hero());
		hero.x = roomWidth / 2;
		hero.y = roomHeight / 2;
		// Assign joysticks to hero
		var joystick = uiContainer.addChild(new Joystick());
		hero.joystick = joystick;
		var aimingJoystick = uiContainer.addChild(new AimingJoystick());
		hero.aimingJoystick = aimingJoystick;
	} else {
		// Reset hero state if restarting
		hero.health = hero.maxHealth;
		hero.x = roomWidth / 2;
		hero.y = roomHeight / 2;
		hero.canExitRoom = false;
		// Reset any active effects or cooldowns if needed
	}
	// Set up initial room
	currentRoom = new Room(1); // Start in room 1
	visitedRooms = [1]; // Mark room 1 as visited initially
	// Set initial background
	var initialBgImage = LK.getAsset(roomBackgroundImages[0], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	initialBgImage.x = roomWidth / 2;
	initialBgImage.y = roomHeight / 2;
	game.addChildAt(initialBgImage, 0);
	game.background = initialBgImage;
	// Setup UI Bars/Text
	var statsBar = LK.getAsset('box', {
		// Simple black bar background for stats
		anchorX: 0.0,
		anchorY: 0.0,
		width: roomWidth,
		height: 100,
		x: 0,
		y: 0,
		color: 0x111111,
		alpha: 0.7
	});
	uiContainer.addChild(statsBar); // Add to UI container
	roomDisplay = new Text2('Room: 1 | Enemies Left: 0', {
		size: 60,
		fill: 0xFFFFFF,
		fontWeight: "bold"
	});
	roomDisplay.x = roomWidth / 2; // Center
	roomDisplay.y = 50; // Middle of bar
	roomDisplay.anchor.set(0.5, 0.5);
	uiContainer.addChild(roomDisplay);
	healthText = new Text2('Health: ' + hero.health, {
		size: 60,
		fill: 0x00FF00,
		fontWeight: "bold"
	});
	healthText.x = 150; // Left side
	healthText.y = 50;
	healthText.anchor.set(0, 0.5);
	uiContainer.addChild(healthText);
	updateRoomDisplay(); // Initial UI text update
	playRoomMusic(currentRoom.number); // Play music for room 1
	currentRoom.startSpawning(); // Start spawning enemies
}
// --- Global UI Buttons ---
// Kill All Button (Debug?)
var killAllButton = LK.getAsset('killAllButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
killAllButton.x = 100;
killAllButton.y = roomHeight - 200; // Position lower left
uiContainer.addChild(killAllButton);
killAllButton.down = function (x, y, obj) {
	if (isPopupActive || isSkillDetailPopupActive || !currentRoom) {
		return;
	} // Don't activate if popups open or no room
	currentRoom.enemies.slice().forEach(function (enemy) {
		// Iterate copy
		if (enemy.die) {
			enemy.die();
		} // Use the die method which handles cleanup
		else if (enemy.parent) {
			enemy.parent.removeChild(enemy);
		} // Fallback
	});
	currentRoom.enemies = []; // Clear array just in case
	currentRoom.enemyCounter = 0;
	currentRoom.enemiesKilled = currentRoom.killGoal; // Mark as cleared for kill count
	updateRoomDisplay();
	checkRoomCleared(); // Trigger cleared state
};
// Switch Weapon Zone/Button
var switchWeaponZone = LK.getAsset('switchWeaponZone', {
	anchorX: 0.5,
	anchorY: 0.5
});
switchWeaponZone.x = roomWidth - 150; // Position lower right
switchWeaponZone.y = roomHeight - 200;
uiContainer.addChild(switchWeaponZone);
switchWeaponZone.interactive = true; // Make the zone itself clickable
switchWeaponZone.down = function (x, y, obj) {
	if (isPopupActive || isSkillDetailPopupActive || !hero) {
		return;
	}
	hero.switchWeapon();
};
// --- Initial Setup Call ---
initializeMainMenu(); // Start by showing the main menu
/**** 
* Game Update Loop
****/ 
game.update = function () {
	// If any popup is active, skip core game updates
	if (isPopupActive || isSkillDetailPopupActive) {
		// Can add logic here for animating menus if needed
		return;
	}
	// --- Core Gameplay Update ---
	if (!hero || !currentRoom) {
		return;
	} // Wait until game is initialized
	// Update Hero (handles movement, attacks, collision checks)
	hero.update();
	// Update Arrows
	// Loop backwards for safe removal while iterating
	for (var j = arrows.length - 1; j >= 0; j--) {
		var arrow = arrows[j];
		if (!arrow) {
			// Safety check if arrow was destroyed elsewhere
			arrows.splice(j, 1);
			continue;
		}
		arrow.update(); // Move arrow
		// Check collision with enemies AFTER moving
		for (var i = currentRoom.enemies.length - 1; i >= 0; i--) {
			var enemy = currentRoom.enemies[i];
			if (!enemy || !enemy.active) {
				continue;
			}
			// Simple distance check for collision
			var hitDx = enemy.x - arrow.x;
			var hitDy = enemy.y - arrow.y;
			var hitDistSqr = hitDx * hitDx + hitDy * hitDy;
			var enemyRadius = (enemy.width || 50) / 2; // Estimate radius
			var arrowRadius = (arrow.width || 10) / 2;
			var collisionDist = enemyRadius + arrowRadius;
			if (hitDistSqr < collisionDist * collisionDist) {
				// Check squared distance
				if (enemy.takeDamage) {
					enemy.takeDamage(arrow.damage);
				} // Damage enemy
				arrow.destroy(); // Destroy arrow (this should remove it from array too)
				// No need to splice here if arrow.destroy() handles it
				break; // Arrow hits one enemy and is destroyed
			}
		}
	} // End arrow update loop
	// Update Enemies (already loop backwards in takeDamage/die)
	// Make a copy of the array to iterate over, in case enemies are removed during update (e.g., by hero attack)
	var enemiesToUpdate = currentRoom.enemies.slice();
	for (var k = 0; k < enemiesToUpdate.length; k++) {
		var enemy = enemiesToUpdate[k];
		// Ensure the enemy wasn't destroyed by a previous update in the same frame
		if (enemy && enemy.active && enemy.update) {
			enemy.update();
		}
	}
	// Room cleared check is now handled within enemy.die()
	// checkRoomCleared(); // Can be removed if die() handles it reliably
}; // End Game Update

===================================================================
--- original.js
+++ change.js
@@ -740,8 +740,21 @@
 
 /**** 
 * Game Code
 ****/ 
+// -- Symphony of Shadows Icons --
+// -- Nexus of Chaos Icons --
+// -- Prism of Potential Icons --
+// -- Forge of Possibilities Icons --
+// -- Echoes of Ancestry Icons --
+// -- Circuit of Ascension Icons --
+// -- Symphony of Shadows Icons --
+// -- Nexus of Chaos Icons --
+// -- Prism of Potential Icons --
+// -- Forge of Possibilities Icons --
+// -- Echoes of Ancestry Icons --
+// -- Circuit of Ascension Icons --
+// Made it grey
 // Add containers to the game stage
 // Adjusted default size
 /**** 
 * Game Configuration & Data
@@ -1399,13 +1412,16 @@
 		}
 	}
 };
 // --- Centralized Skill Tree Layout Data ---
+// This structure holds the background image, list of skills (nodes),
+// node positions, and the mapping of skill names to their icon asset names for each tree.
 var skillTreeLayouts = {
 	'The Circuit of Ascension': {
 		backgroundAsset: 'popup_circuitofascension',
 		nodes: ['Data Spike', 'Reflex Accelerator', 'Overclock Core', 'Neural Hijack', 'Dodge Matrix', 'Power Surge', 'Overload Blast'],
 		positions: {
+			// Positions from original code
 			'Data Spike': {
 				x: 2048 / 4 - 50,
 				y: 2732 / 6 - 50 + 100
 			},
@@ -1432,15 +1448,25 @@
 			'Overload Blast': {
 				x: 2048 / 2,
 				y: 3 * 2732 / 6 + 50 + 100
 			}
+		},
+		icons: {
+			// *** Replace these values with your actual asset names defined in LK.init.image *** 
+			'Data Spike': 'Data Spike_icon',
+			'Reflex Accelerator': 'Reflex Accelerator_icon',
+			'Overclock Core': 'Overclock Core_icon',
+			'Neural Hijack': 'Neural Hijack_icon',
+			'Dodge Matrix': 'Dodge Matrix_icon',
+			'Power Surge': 'Power Surge_icon',
+			'Overload Blast': 'Overload Blast_icon'
 		}
-		// icons: { 'Data Spike': 'data_spike_icon', ... } // Add actual icon asset IDs here if defined
 	},
 	'The Echoes of Ancestry': {
 		backgroundAsset: 'popup_echoesofancestry',
 		nodes: ['Ancient Wisdom', 'Elemental Mastery', 'Warrior Spirit', 'Beast Tamer', 'Herbal Remedies', 'Spirit Guidance', 'Legendary Ancestor'],
 		positions: {
+			// Positions from original code
 			'Ancient Wisdom': {
 				x: 2048 / 4 - 50,
 				y: 2732 / 6 - 50 + 100
 			},
@@ -1467,15 +1493,25 @@
 			'Legendary Ancestor': {
 				x: 2048 / 2,
 				y: 3 * 2732 / 6 + 50 + 100
 			}
+		},
+		icons: {
+			// *** Replace these values with your actual asset names defined in LK.init.image *** 
+			'Ancient Wisdom': 'Ancient Wisdom_icon',
+			'Elemental Mastery': 'Elemental Mastery_icon',
+			'Warrior Spirit': 'Warrior Spirit_icon',
+			'Beast Tamer': 'Beast Tamer_icon',
+			'Herbal Remedies': 'Herbal Remedies_icon',
+			'Spirit Guidance': 'Spirit Guidance_icon',
+			'Legendary Ancestor': 'Legendary Ancestor_icon'
 		}
-		// icons: { ... }
 	},
 	'The Forge of Possibilities': {
 		backgroundAsset: 'popup_forgeofpossibilities',
 		nodes: ['Adaptive Construction', 'Elemental Infusion', 'Modular Enhancement', 'Resourceful Salvage', 'Hybrid Crafting', 'Runic Slots', 'Masterwork Creation'],
 		positions: {
+			// Positions from original code
 			'Adaptive Construction': {
 				x: 2048 / 4 - 50,
 				y: 2732 / 6 - 50 + 100
 			},
@@ -1502,15 +1538,25 @@
 			'Masterwork Creation': {
 				x: 2048 / 2,
 				y: 3 * 2732 / 6 + 50 + 100
 			}
+		},
+		icons: {
+			// *** Replace these values with your actual asset names defined in LK.init.image *** 
+			'Adaptive Construction': 'Adaptive Construction_icon',
+			'Elemental Infusion': 'Elemental Infusion_icon',
+			'Modular Enhancement': 'Modular Enhancement_icon',
+			'Resourceful Salvage': 'Resourceful Salvage_icon',
+			'Hybrid Crafting': 'Hybrid Crafting_icon',
+			'Runic Slots': 'Runic Slots_icon',
+			'Masterwork Creation': 'Masterwork Creation_icon'
 		}
-		// icons: { ... }
 	},
 	'The Prism of Potential': {
 		backgroundAsset: 'popup_prismofpotential',
 		nodes: ['Red Radiance', 'Blue Bulwark', 'Green Growth', 'Yellow Zephyr', 'Indigo Insight', 'Chromatic Fusion', 'Prismatic Ascendance'],
 		positions: {
+			// Positions from original code
 			'Red Radiance': {
 				x: 2048 / 4 - 50,
 				y: 2732 / 6 - 50 + 100
 			},
@@ -1537,15 +1583,25 @@
 			'Prismatic Ascendance': {
 				x: 2048 / 2,
 				y: 3 * 2732 / 6 + 50 + 100
 			}
+		},
+		icons: {
+			// *** Replace these values with your actual asset names defined in LK.init.image *** 
+			'Red Radiance': 'Red Radiance_icon',
+			'Blue Bulwark': 'Blue Bulwark_icon',
+			'Green Growth': 'Green Growth_icon',
+			'Yellow Zephyr': 'Yellow Zephyr_icon',
+			'Indigo Insight': 'Indigo Insight_icon',
+			'Chromatic Fusion': 'Chromatic Fusion_icon',
+			'Prismatic Ascendance': 'Prismatic Ascendance_icon'
 		}
-		// icons: { ... }
 	},
 	'The Nexus of Chaos': {
 		backgroundAsset: 'popup_nexusofchaos',
 		nodes: ['Chaotic Spark', 'Entropy Shield', 'Unstable Rift', 'Anomaly Shift', 'Cascade of Disorder', 'Fractured Fate', 'Reality Collapse'],
 		positions: {
+			// Positions from original code
 			'Chaotic Spark': {
 				x: 2048 / 4 - 50,
 				y: 2732 / 6 - 50 + 100
 			},
@@ -1572,15 +1628,25 @@
 			'Reality Collapse': {
 				x: 2048 / 2,
 				y: 3 * 2732 / 6 + 50 + 100
 			}
+		},
+		icons: {
+			// *** Replace these values with your actual asset names defined in LK.init.image *** 
+			'Chaotic Spark': 'Chaotic Spark_icon',
+			'Entropy Shield': 'Entropy Shield_icon',
+			'Unstable Rift': 'Unstable Rift_icon',
+			'Anomaly Shift': 'Anomaly Shift_icon',
+			'Cascade of Disorder': 'Cascade of Disorder_icon',
+			'Fractured Fate': 'Fractured Fate_icon',
+			'Reality Collapse': 'Reality Collapse_icon'
 		}
-		// icons: { ... }
 	},
 	'The Symphony of Shadows': {
 		backgroundAsset: 'popup_symphonyofshadows',
 		nodes: ['Whispered Steps', 'Nightfall Veil', 'Serrated Shade', 'Shadow Familiar', 'Muffled Strikes', 'Umbral Echoes', 'Midnight Crescendo'],
 		positions: {
+			// Positions from original code
 			'Whispered Steps': {
 				x: 2048 / 4 - 50,
 				y: 2732 / 6 - 50 + 100
 			},
@@ -1607,10 +1673,19 @@
 			'Midnight Crescendo': {
 				x: 2048 / 2,
 				y: 3 * 2732 / 6 + 50 + 100
 			}
+		},
+		icons: {
+			// *** Replace these values with your actual asset names defined in LK.init.image *** 
+			'Whispered Steps': 'Whispered Steps_icon',
+			'Nightfall Veil': 'Nightfall Veil_icon',
+			'Serrated Shade': 'Serrated Shade_icon',
+			'Shadow Familiar': 'Shadow Familiar_icon',
+			'Muffled Strikes': 'Muffled Strikes_icon',
+			'Umbral Echoes': 'Umbral Echoes_icon',
+			'Midnight Crescendo': 'Midnight Crescendo_icon'
 		}
-		// icons: { ... }
 	}
 };
 /**** 
 * Global Variables (Gameplay State)
@@ -1806,57 +1881,72 @@
 	menuContainer.addChild(skillPopup);
 	isSkillDetailPopupActive = true; // Set the specific flag
 	isPopupActive = false; // Ensure general flag is off if only detail popup is shown
 }
-// Creates a single node in the skill tree view
+// Creates a single node in the skill tree view (Modified for unique icons)
 function createSkillTreeNode(skillName, position, parentPopup) {
 	var skillData = skillDefinitions[skillName];
 	if (!skillData) {
 		return;
 	}
-	// --- Icon Placeholder ---
-	// var iconAssetId = skillTreeLayouts[skillData.tree]?.icons?.[skillName] || 'glowing_line_asset'; // Use specific icon if available
-	var iconAssetId = 'glowing_line_asset'; // Placeholder
-	var skillNodeGraphic = LK.getAsset(iconAssetId, {
-		anchorX: 0.5,
-		anchorY: 0.5
-		// scaleX: 1, scaleY: 1, // Use default scale or adjust as needed
-		// width: 100, height: 100, // Use asset's default size or override
-	});
-	// Apply color only if it's the placeholder shape
-	if (iconAssetId === 'glowing_line_asset') {
-		skillNodeGraphic.color = 0xc05bf1;
-		skillNodeGraphic.width = 80; // Adjust size
-		skillNodeGraphic.height = 80;
+	// --- Get Specific Icon Asset Name ---
+	var iconAssetId = 'skill_node_placeholder'; // Default to placeholder
+	var treeLayout = skillTreeLayouts[skillData.tree];
+	if (treeLayout && treeLayout.icons && treeLayout.icons[skillName]) {
+		iconAssetId = treeLayout.icons[skillName]; // Use specific asset name if mapped
 	} else {
-		// Optional: Scale real icons if needed
-		skillNodeGraphic.scale.set(3);
+		// Optional: Log a warning if a specific icon mapping is missing
+		// console.log("Warning: Icon asset mapping missing for skill: " + skillName);
 	}
+	// --- Create Node Graphic ---
+	var skillNodeGraphic = null;
+	try {
+		skillNodeGraphic = LK.getAsset(iconAssetId, {
+			anchorX: 0.5,
+			// Set anchor in asset definition or here if needed
+			anchorY: 0.5
+			// width: 80, height: 80 // Set size in asset definition preferably
+		});
+	} catch (e) {
+		// Fallback if the specific asset failed to load (e.g., not defined yet)
+		console.log("Error loading asset '" + iconAssetId + "', using placeholder. Error: " + e);
+		iconAssetId = 'skill_node_placeholder'; // Ensure we use placeholder name
+		skillNodeGraphic = LK.getAsset(iconAssetId, {
+			anchorX: 0.5,
+			anchorY: 0.5
+			// width: 80, height: 80 // Defined in placeholder asset
+		});
+	}
 	skillNodeGraphic.x = position.x;
 	skillNodeGraphic.y = position.y;
 	skillNodeGraphic.interactive = true;
 	// --- Points Text ---
 	var points = skillData.points;
 	var maxPoints = skillData.max;
 	var pointsText = new Text2(points + '/' + maxPoints, {
-		size: 50,
+		size: 40,
 		fill: 0xFFFFFF,
 		fontWeight: "bold",
+		// Slightly smaller text
 		stroke: 0x000000,
-		strokeThickness: 4
+		strokeThickness: 3 // Thinner stroke maybe
 	});
 	pointsText.x = position.x;
-	pointsText.y = position.y + 60; // Offset below node (adjust based on icon size)
-	pointsText.anchor.set(0.5, 0);
+	// Adjust Y offset based on your icon size (assuming icon is anchored center)
+	// If your icons are ~80px tall, offset by slightly more than half height
+	pointsText.y = position.y + 50; // Adjust this value as needed
+	pointsText.anchor.set(0.5, 0); // Anchor horizontal center, vertical top
 	pointsText.name = skillName + "_pointsText"; // Unique name for updates
 	// --- Click Handler ---
 	skillNodeGraphic.down = function () {
 		displaySkillDetailPopup(skillName); // Call the single generic display function
-		// Visual feedback (Flash)
-		var originalTint = skillNodeGraphic.tint;
+		// Visual feedback (Flash) - Optional
+		var originalTint = skillNodeGraphic.tint !== undefined ? skillNodeGraphic.tint : null;
 		skillNodeGraphic.tint = 0xFFFF00; // Yellow flash
 		LK.setTimeout(function () {
-			skillNodeGraphic.tint = originalTint;
+			if (skillNodeGraphic.tint !== undefined) {
+				skillNodeGraphic.tint = originalTint;
+			}
 		}, 150);
 	};
 	parentPopup.addChild(skillNodeGraphic);
 	parentPopup.addChild(pointsText);
@@ -1884,23 +1974,26 @@
 	newPopup.addChild(newPopupBackground);
 	// Back Button (Use the class)
 	var backButton = new BackButton();
 	newPopup.addChild(backButton);
-	// Title
+	// Title (Modified for better centering and wrapping)
 	var skillTreeTitle = new Text2(skillTreeName, {
 		size: 100,
 		fill: 0xFFFFFF,
 		fontWeight: "bold",
-		// Slightly smaller title
 		fontFamily: "Techno, sans-serif",
 		letterSpacing: 2,
 		stroke: 0x00FFCC,
 		strokeThickness: 3,
-		align: 'center'
+		align: 'center',
+		// Explicitly center align the text
+		wordWrap: true,
+		// Enable word wrap
+		wordWrapWidth: roomWidth * 0.8 // Wrap if title exceeds 80% of screen width
 	});
-	skillTreeTitle.x = roomWidth / 2;
+	skillTreeTitle.x = roomWidth / 2; // Center horizontally
 	skillTreeTitle.y = 100; // Position near top
-	skillTreeTitle.anchor.set(0.5, 0);
+	skillTreeTitle.anchor.set(0.5, 0); // Anchor at horizontal center, vertical top
 	newPopup.addChild(skillTreeTitle);
 	// Create Nodes
 	layoutData.nodes.forEach(function (skillName) {
 		var position = layoutData.positions[skillName];