/**** 
* Classes
****/ 
// AimingJoystick class for aiming separately from movement
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 = 2048 - joystickBackground.width / 2 - 100;
	self.y = 2732 - joystickBackground.height / 2 - 100;
	var maxRadius = 100;
	var isDragging = false;
	self.down = function (x, y, obj) {
		isDragging = true;
	};
	self.move = function (x, y, obj) {
		if (isDragging && !isPopupActive) {
			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.up = function (x, y, obj) {
		isDragging = false;
		joystickHandle.x = 0;
		joystickHandle.y = 0;
	};
	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 provided
		}
		return Math.atan2(joystickHandle.y, joystickHandle.x);
	};
	self.hasInput = function () {
		return joystickHandle.x !== 0 || joystickHandle.y !== 0;
	};
	return self;
});
// Arrow class representing the arrows fired by the hero
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;
	self.update = function () {
		self.x += Math.cos(self.rotation) * self.speed;
		self.y += Math.sin(self.rotation) * self.speed;
		if (self.x < 0 || self.x > 2048 || self.y < 0 || self.y > 2732) {
			self.destroy();
		}
	};
});
// BackButton class representing the back button functionality
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;
	self.down = function () {
		menuContainer.removeChild(self.parent);
		menuContainer.addChild(skillTreePopup);
	};
	return self;
});
// Enemy class representing the enemy character
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy_run1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var frames = [LK.getAsset('enemy_run1', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('enemy_run2', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('enemy_run3', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('enemy_run4', {
		anchorX: 0.5,
		anchorY: 0.5
	})];
	self.speed = 2 + Math.random() * 0.5;
	self.damageCooldown = 0;
	var currentFrame = 0;
	var frameDelay = 30;
	var frameCounter = 0;
	self.update = function () {
		frameCounter++;
		if (frameCounter >= frameDelay) {
			frameCounter = 0;
			self.removeChild(enemyGraphics);
			currentFrame = (currentFrame + 1) % frames.length;
			enemyGraphics = self.addChild(frames[currentFrame]);
		}
		var offsetX = (Math.random() - 0.5) * 20;
		var offsetY = (Math.random() - 0.5) * 20;
		var dx = hero.x + offsetX - self.x;
		var dy = hero.y + offsetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		var minDistance = 70;
		if (distance > minDistance) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
			self.rotation = Math.atan2(dy, dx);
		} else {
			if (self.damageCooldown <= 0) {
				hero.health -= 5;
				self.damageCooldown = 60;
				updateRoomDisplay();
			} else {
				self.damageCooldown--;
			}
			self.x -= dx / distance * (minDistance - distance);
			self.y -= dy / distance * (minDistance - distance);
		}
		if (self.x < wallThickness) {
			self.x = wallThickness;
		}
		if (self.x > roomWidth - wallThickness) {
			self.x = roomWidth - wallThickness;
		}
		if (self.y < wallThickness) {
			self.y = wallThickness;
		}
		if (self.y > roomHeight - wallThickness) {
			self.y = roomHeight - wallThickness;
		}
	};
	return self;
});
// Hero class representing the player character
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;
	self.bowGraphics.visible = false;
	self.attackCooldown = 0;
	self.isAttacking = false;
	self.health = 100;
	self.attackDuration = 20;
	self.attackDurationCounter = 0; // Counter to track swing animation progress
	self.weaponType = 1;
	self.attackRange = 60;
	self.attackDamage = 10;
	self.speed = 3;
	// Attack speeds for different weapons
	self.swordAttackSpeed = 45; // Frames between sword attacks
	self.bowAttackSpeed = 30; // Frames between arrow shots
	self.joystick = null;
	self.aimingJoystick = null;
	// Properties to track facing direction separately from aiming direction
	self.facingDirection = 0; // Angle in radians
	self.update = function () {
		// Movement handling
		var direction = this.joystick ? this.joystick.getDirection() : {
			x: 0,
			y: 0
		};
		var nextX = this.x + direction.x * this.speed;
		var nextY = this.y + direction.y * this.speed;
		// Wall collision detection
		if (nextX < wallThickness && !(nextY >= entrances.left.yStart && nextY <= entrances.left.yEnd)) {
			nextX = wallThickness;
		} else if (nextX > roomWidth - wallThickness && !(nextY >= entrances.right.yStart && nextY <= entrances.right.yEnd)) {
			nextX = roomWidth - wallThickness;
		}
		if (nextY < wallThickness && !(nextX >= entrances.top.xStart && nextX <= entrances.top.xEnd)) {
			nextY = wallThickness;
		} else if (nextY > roomHeight - wallThickness && !(nextX >= entrances.bottom.xStart && nextX <= entrances.bottom.xEnd)) {
			nextY = roomHeight - wallThickness;
		}
		this.x = nextX;
		this.y = nextY;
		// Update facing direction if moving
		if (direction.x !== 0 || direction.y !== 0) {
			self.facingDirection = Math.atan2(direction.y, direction.x);
			// Only rotate hero graphics for movement if not aiming
			if (!self.aimingJoystick || !self.aimingJoystick.hasInput()) {
				// Use facing direction for hero rotation
				self.rotation = self.facingDirection;
			}
		}
		// If aiming joystick has input, use that direction for weapon aiming
		if (self.aimingJoystick && self.aimingJoystick.hasInput()) {
			var aimAngle = self.aimingJoystick.getRotation();
			if (aimAngle !== null) {
				// Rotate the hero for aiming
				self.rotation = aimAngle;
				// Position weapons correctly based on aim direction
				if (self.weaponType === 1) {
					// Sword
					self.swordGraphics.x = heroGraphics.width / 2 + Math.cos(aimAngle - self.rotation) * 20;
					self.swordGraphics.y = Math.sin(aimAngle - self.rotation) * 20;
				} else if (self.weaponType === 2) {
					// Bow
					self.bowGraphics.x = heroGraphics.width / 2;
					self.bowGraphics.rotation = 0; // Bow follows hero rotation
				}
			}
		}
		// Auto-attack system - continuously attack based on weapon type
		if (!isPopupActive) {
			if (self.attackCooldown > 0) {
				self.attackCooldown--;
			}
			// For sword attacks - only start a new attack if not already attacking and cooldown is complete
			if (self.weaponType === 1 && !self.isAttacking && self.attackCooldown <= 0) {
				// Start a new sword attack
				self.isAttacking = true;
				self.attackDurationCounter = self.attackDuration; // Track swing progress separately from cooldown
			}
			// For bow attacks
			if (self.weaponType === 2 && self.attackCooldown <= 0) {
				// Fire an arrow
				self.fireArrow();
				self.attackCooldown = self.bowAttackSpeed;
			}
		}
		// Attack animation and logic for sword
		if (self.isAttacking) {
			// Track swing progress using a dedicated counter
			if (self.attackDurationCounter > 0) {
				self.attackDurationCounter--;
			}
			var swingProgress = (self.attackDuration - self.attackDurationCounter) / self.attackDuration;
			self.swordGraphics.rotation = Math.sin(swingProgress * Math.PI) * 1.2;
			self.swordGraphics.x = heroGraphics.width / 2 + Math.cos(swingProgress * Math.PI) * 30;
			self.swordGraphics.y = Math.sin(swingProgress * Math.PI) * 30;
			// End swing animation when appropriate
			if (swingProgress >= 1) {
				self.isAttacking = false;
				self.swordGraphics.rotation = 0;
				self.attackCooldown = self.swordAttackSpeed; // Only set cooldown after swing completes
			} else {
				// Check for enemies hit by sword during swing
				for (var i = currentRoom.enemies.length - 1; i >= 0; i--) {
					var enemy = currentRoom.enemies[i];
					var angleToEnemy = Math.atan2(enemy.y - self.y, enemy.x - self.x);
					var angleDifference = Math.abs(angleToEnemy - self.rotation);
					var swordDx = enemy.x - (self.x + Math.cos(self.rotation) * self.attackRange);
					var swordDy = enemy.y - (self.y + Math.sin(self.rotation) * self.attackRange);
					var swordDistance = Math.sqrt(swordDx * swordDx + swordDy * swordDy);
					if (swordDistance < self.attackRange && angleDifference < Math.PI / 4) {
						enemy.health -= self.attackDamage;
						if (enemy.health <= 0) {
							currentRoom.enemiesKilled++;
							currentRoom.enemyCounter--;
							enemy.destroy();
							currentRoom.enemies.splice(i, 1);
							updateRoomDisplay();
						}
					}
				}
			}
		} else {
			self.swordGraphics.rotation = 0;
		}
	};
	// Method to fire arrow in aimed direction
	self.fireArrow = function () {
		if (self.weaponType !== 2) {
			return;
		} // Only fire if bow is equipped
		var arrow = new Arrow();
		arrow.x = self.x;
		arrow.y = self.y;
		// Use aiming joystick direction if available, otherwise use facing direction
		var fireDirection = self.aimingJoystick && self.aimingJoystick.hasInput() ? self.aimingJoystick.getRotation() : self.rotation;
		arrow.rotation = fireDirection;
		arrows.push(arrow);
		game.addChild(arrow);
	};
});
// Joystick class representing the on-screen joystick for 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 = 2732 - joystickBackground.height / 2 - 100;
	var maxRadius = 100;
	var isDragging = false;
	self.down = function (x, y, obj) {
		isDragging = true;
	};
	self.move = function (x, y, obj) {
		if (isDragging && !isPopupActive) {
			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.up = function (x, y, obj) {
		isDragging = false;
		joystickHandle.x = 0;
		joystickHandle.y = 0;
	};
	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;
});
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.update = function () {
		self.x += self.vx;
		self.y += self.vy;
		self.rotation += 0.1; // Maintain spinning effect
		if (self.x < 0 || self.x > 2048 || self.y < 0 || self.y > 2732) {
			self.destroy();
		}
		if (self.intersects(hero)) {
			hero.health -= self.damage;
			self.destroy();
			updateRoomDisplay();
		}
	};
	return self;
});
var RangedEnemy = Container.expand(function () {
	var self = Container.call(this);
	var rangedGraphics = self.attachAsset('ranged_run1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var frames = [LK.getAsset('ranged_run1', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('ranged_run2', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('ranged_run3', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('ranged_run4', {
		anchorX: 0.5,
		anchorY: 0.5
	})];
	self.speed = 2.0;
	self.health = 20;
	var currentFrame = 0;
	var frameDelay = 30;
	var frameCounter = 0;
	var projectileCooldown = 180; // 3 seconds at 60 FPS
	self.update = function () {
		frameCounter++;
		if (frameCounter >= frameDelay) {
			frameCounter = 0;
			self.removeChild(rangedGraphics);
			currentFrame = (currentFrame + 1) % frames.length;
			rangedGraphics = self.addChild(frames[currentFrame]);
		}
		var offsetX = (Math.random() - 0.5) * 20;
		var offsetY = (Math.random() - 0.5) * 20;
		var dx = hero.x + offsetX - self.x;
		var dy = hero.y + offsetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		var desiredDistance = 350; // Further increase the desired distance to maintain from the hero
		if (distance < desiredDistance) {
			self.x -= dx / distance * self.speed;
			self.y -= dy / distance * self.speed;
		} else if (distance > desiredDistance) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
		self.rotation = Math.atan2(dy, dx);
		if (self.x < wallThickness) {
			self.x = wallThickness;
		}
		if (self.x > roomWidth - wallThickness) {
			self.x = roomWidth - wallThickness;
		}
		if (self.y < wallThickness) {
			self.y = wallThickness;
		}
		if (self.y > roomHeight - wallThickness) {
			self.y = roomHeight - wallThickness;
		}
		if (projectileCooldown <= 0) {
			self.shootProjectile();
			projectileCooldown = 180; // Increase cooldown to 3 seconds at 60 FPS
		} else {
			projectileCooldown--;
		}
	};
	self.shootProjectile = function () {
		var projectile = new Projectile('ranged_attack');
		projectile.x = self.x;
		projectile.y = self.y;
		var targetX = hero.x;
		var targetY = hero.y;
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var angle = Math.atan2(dy, dx);
		projectile.rotation = angle;
		projectile.vx = Math.cos(angle) * projectile.speed;
		projectile.vy = Math.sin(angle) * projectile.speed;
		game.addChild(projectile);
	};
	return self;
});
// StartGameButton class representing the start game button functionality
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 = 2048 / 2;
	self.y = 2732 - 400;
	self.down = function () {
		menuContainer.removeChild(skillTreePopup);
		isPopupActive = false;
		isDataSpikePopupActive = false;
		initializeGame();
		// Music is now handled in initializeGame -> playRoomMusic
	};
	return self;
});
var TankEnemy = Container.expand(function () {
	var self = Container.call(this);
	var tankGraphics = self.attachAsset('tank_run1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var frames = [LK.getAsset('tank_run1', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('tank_run2', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('tank_run3', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('tank_run4', {
		anchorX: 0.5,
		anchorY: 0.5
	})];
	self.speed = 1.0;
	self.health = 50;
	var currentFrame = 0;
	var frameDelay = 30;
	var frameCounter = 0;
	self.update = function () {
		frameCounter++;
		if (frameCounter >= frameDelay) {
			frameCounter = 0;
			self.removeChild(tankGraphics);
			currentFrame = (currentFrame + 1) % frames.length;
			tankGraphics = self.addChild(frames[currentFrame]);
		}
		// Movement logic similar to Enemy class
		var offsetX = (Math.random() - 0.5) * 20;
		var offsetY = (Math.random() - 0.5) * 20;
		var dx = hero.x + offsetX - self.x;
		var dy = hero.y + offsetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		var minDistance = 70;
		if (distance > minDistance) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
			self.rotation = Math.atan2(dy, dx);
		}
		if (self.x < wallThickness) {
			self.x = wallThickness;
		}
		if (self.x > roomWidth - wallThickness) {
			self.x = roomWidth - wallThickness;
		}
		if (self.y < wallThickness) {
			self.y = wallThickness;
		}
		if (self.y > roomHeight - wallThickness) {
			self.y = roomHeight - wallThickness;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
function addDirectionalArrows() {
	var arrowDirections = ['top', 'bottom', 'left', 'right'];
	arrowDirections.forEach(function (direction) {
		var arrow = LK.getAsset('directionalArrow', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		switch (direction) {
			case 'top':
				arrow.x = 2048 / 2;
				arrow.y = 500;
				arrow.rotation = 0;
				break;
			case 'bottom':
				arrow.x = 2048 / 2;
				arrow.y = 2732 - 500;
				arrow.rotation = Math.PI;
				break;
			case 'left':
				arrow.x = 500;
				arrow.y = 2732 / 2;
				arrow.rotation = -Math.PI / 2;
				break;
			case 'right':
				arrow.x = 2048 - 500;
				arrow.y = 2732 / 2;
				arrow.rotation = Math.PI / 2;
				break;
		}
		game.addChild(arrow);
		LK.effects.flashObject(arrow, 0xffffff, 1000); // Flash effect
	});
}
function displayWhisperedStepsPopup() {
	var popup = createSkillPopup('Whispered Steps', 'Move silently, becoming harder to detect. Occasionally evade attacks entirely, as your footsteps blend into the ambient darkness.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayNightfallVeilPopup() {
	var popup = createSkillPopup('Nightfall Veil', 'Briefly cloak yourself in shadow. While cloaked, project a faint silhouette to mislead foes. Attacks aimed at you may strike only empty air.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displaySerratedShadePopup() {
	var popup = createSkillPopup('Serrated Shade', 'Enhance your weapons with shadowy edges. Attacks may lacerate enemies, causing bleed-like damage over time as the darkness seeps into their wounds.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayShadowFamiliarPopup() {
	var popup = createSkillPopup('Shadow Familiar', 'Summon a small, dark entity that assists you. It distracts enemies, occasionally nipping at their heels and granting you openings to strike.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayMuffledStrikesPopup() {
	var popup = createSkillPopup('Muffled Strikes', 'Attacks produce little sound, reducing enemy awareness. Some foes fail to fully react, taking extra critical hits as they struggle to track your movements.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayUmbralEchoesPopup() {
	var popup = createSkillPopup('Umbral Echoes', 'Your attacks leave lingering echoes of shadow. These echoes confuse enemies, causing them to strike illusions or hesitate, giving you more control in battle.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayMidnightCrescendoPopup() {
	var popup = createSkillPopup('Midnight Crescendo', '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.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayChaoticSparkPopup() {
	var popup = createSkillPopup('Chaotic Spark', 'Your attacks sometimes produce random elemental effects. Damage types and minor status effects vary unpredictably, keeping foes off-balance.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayEntropyShieldPopup() {
	var popup = createSkillPopup('Entropy Shield', 'Surround yourself with shifting energy fields. Each incoming hit has a chance to fizzle harmlessly or rebound, dealing random damage back to attackers.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayUnstableRiftPopup() {
	var popup = createSkillPopup('Unstable Rift', 'Occasionally summon a pocket of chaos in battle. Enemies near the rift suffer random debuffs—slowing, poisoning, burning—ever-changing, never stable.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayAnomalyShiftPopup() {
	var popup = createSkillPopup('Anomaly Shift', 'Briefly warp your form. Gain random beneficial buffs—from speed and regeneration to critical chance—but each application is uncertain, never guaranteed.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayCascadeOfDisorderPopup() {
	var popup = createSkillPopup('Cascade of Disorder', 'Trigger a chain reaction of volatile energies. Attacks may ignite unpredictable chain effects, spreading to multiple enemies or amplifying certain strikes.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayFracturedFatePopup() {
	var popup = createSkillPopup('Fractured Fate', 'Tap into temporal chaos. Sometimes attacks hit twice, or cooldowns shorten unexpectedly. Fate bends momentarily, granting you unpredictable bursts of advantage.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayRealityCollapsePopup() {
	var popup = createSkillPopup('Reality Collapse', '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.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayRedRadiancePopup() {
	var popup = createSkillPopup('Red Radiance', '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.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayBlueBulwarkPopup() {
	var popup = createSkillPopup('Blue Bulwark', '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.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayGreenGrowthPopup() {
	var popup = createSkillPopup('Green Growth', '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.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayYellowZephyrPopup() {
	var popup = createSkillPopup('Yellow Zephyr', '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.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayIndigoInsightPopup() {
	var popup = createSkillPopup('Indigo Insight', '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.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayChromaticFusionPopup() {
	var popup = createSkillPopup('Chromatic Fusion', '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.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayPrismaticAscendancePopup() {
	var popup = createSkillPopup('Prismatic Ascendance', 'Briefly harness all hues at once, greatly enhancing elemental power. Attacks may inflict multiple ailments, and you gain increased damage, defense, healing, and speed.');
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayAdaptiveConstructionPopup() {
	// Firebrand Enchantment: Imbue your weapon with searing flame—each rank adds +5 % fire damage and +2 % chance to ignite on hit.
	var skillName = 'Adaptive Construction';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
	var fireDmgPerRank = 5;
	var ignitePerRank = 2;
	var currentFire = points * fireDmgPerRank;
	var currentIgnite = points * ignitePerRank;
	var description = '';
	if (points === 0) {
		description = "Imbue your weapon with searing flame, adding 5% fire damage and 2% chance to ignite on hit.";
	} else if (points < maxPoints) {
		description = "Imbue your weapon with searing flame, adding " + (points + 1) * fireDmgPerRank + "% fire damage and " + (points + 1) * ignitePerRank + "% chance to ignite on hit (Currently " + currentFire + "% fire damage / " + currentIgnite + "% ignite).";
	} else {
		description = "Maximum rank reached. Imbue your weapon with searing flame, adding 25% fire damage and 10% chance to ignite on hit.";
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayElementalInfusionPopup() {
	// Elemental Tempo: Every swing or shot has a passive chance to inflict a random elemental effect—proc chance scales +10 %, +8 %, +6 %, +4 %, then +2 % (max 30 % at rank 5).
	var skillName = 'Elemental Infusion';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
	var procs = [10, 8, 6, 4, 2];
	var currentProc = 0;
	for (var i = 0; i < points; i++) {
		currentProc += procs[i];
	}
	var description = '';
	if (points === 0) {
		description = "Every attack has a 10% chance to inflict a random elemental effect.";
	} else if (points < maxPoints) {
		var nextProc = procs[points];
		description = "Every attack has a " + (currentProc + nextProc) + "% chance to inflict a random elemental effect (Currently " + currentProc + "%).";
	} else {
		description = "Maximum rank reached. Every attack has a 30% chance to inflict a random elemental effect.";
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayModularEnhancementPopup() {
	// Mechanical Reflex: Bolted springs release on hit, giving you a chance to instantly ready your weapon for an extra strike—proc chance scales +3 %, +6 %, +9 %, +12 %, then +15 % (max 15 % at rank 5).
	var skillName = 'Modular Enhancement';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
	var procs = [3, 3, 3, 3, 3]; // Actually, the example says +3, +6, +9, +12, +15, but the text says max 15% at rank 5, so let's use +3 per rank for 15% at 5.
	var currentProc = points * 3;
	var description = '';
	if (points === 0) {
		description = "Each hit has a 3% chance to instantly ready your weapon for an extra strike.";
	} else if (points < maxPoints) {
		description = "Each hit has a " + (points + 1) * 3 + "% chance to instantly ready your weapon for an extra strike (Currently " + currentProc + "%).";
	} else {
		description = "Maximum rank reached. Each hit has a 15% chance to instantly ready your weapon for an extra strike.";
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayResourcefulSalvagePopup() {
	// Resourceful Salvage: Disassemble enemy gear on kill for a small chance to siphon extra skill‑point gain—proc chance scales 2 %→6 % and buff strength/duration scales +10 % for 5 s up to +20 % for 15 s.
	var skillName = 'Resourceful Salvage';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
	var procChances = [2, 3, 4, 5, 6];
	var buffStrengths = [10, 12, 14, 16, 20];
	var buffDurations = [5, 7, 9, 12, 15];
	var currentProc = points > 0 ? procChances[points - 1] : 0;
	var currentBuff = points > 0 ? buffStrengths[points - 1] : 0;
	var currentDur = points > 0 ? buffDurations[points - 1] : 0;
	var description = '';
	if (points === 0) {
		description = "Killing an enemy has a 2% chance to grant +10% skill‑point gain for 5 seconds.";
	} else if (points < maxPoints) {
		var nextProc = procChances[points];
		var nextBuff = buffStrengths[points];
		var nextDur = buffDurations[points];
		description = "Killing an enemy has a " + nextProc + "% chance to grant +" + nextBuff + "% skill‑point gain for " + nextDur + " seconds (Currently " + currentProc + "% / +" + currentBuff + "% / " + currentDur + "s).";
	} else {
		description = "Maximum rank reached. Killing an enemy has a 6% chance to grant +20% skill‑point gain for 15 seconds.";
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayHybridCraftingPopup() {
	// Hybrid Crafting (1/1): 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.
	var skillName = 'Hybrid Crafting';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 1;
	var description = '';
	if (points === 0) {
		description = "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.";
	} else {
		description = "Maximum rank reached. 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.";
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayRunicSlotsPopup() {
	// Gem Harvester: Kills can drop volatile runic gems that grant a random buff—buff potency and duration scale from +5 % for 3 s up to +15 % for 8 s, and drop chance scales 5 %→20 %.
	var skillName = 'Runic Slots';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
	var dropChances = [5, 8, 12, 16, 20];
	var buffPotencies = [5, 7, 9, 12, 15];
	var buffDurations = [3, 4, 5, 6, 8];
	var currentDrop = points > 0 ? dropChances[points - 1] : 0;
	var currentBuff = points > 0 ? buffPotencies[points - 1] : 0;
	var currentDur = points > 0 ? buffDurations[points - 1] : 0;
	var description = '';
	if (points === 0) {
		description = "Killing an enemy has a 5% chance to drop a runic gem granting a random +5% buff for 3 seconds.";
	} else if (points < maxPoints) {
		var nextDrop = dropChances[points];
		var nextBuff = buffPotencies[points];
		var nextDur = buffDurations[points];
		description = "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 {
		description = "Maximum rank reached. Killing an enemy has a 20% chance to drop a runic gem granting a random +15% buff for 8 seconds.";
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayMasterworkCreationPopup() {
	// Masterwork Creation: Temporarily transform your weapon into a masterwork artifact—damage bonus, arrow‑cleave count, and shockwave radius all increase with each of 3 ranks.
	var skillName = 'Masterwork Creation';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 3;
	var dmgBonuses = [30, 60, 90];
	var cleaveCounts = [1, 2, 3];
	var shockwaveRadii = [1, 2, 3];
	var description = '';
	if (points === 0) {
		description = "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 < 3) {
		description = "Transforms your weapon for 6s, granting +" + dmgBonuses[points] + "% damage, arrows cleave " + cleaveCounts[points] + " extra target" + (cleaveCounts[points] > 1 ? "s" : "") + ", and melee triggers a " + shockwaveRadii[points] + "-unit shockwave (Currently +" + dmgBonuses[points - 1] + "% / " + cleaveCounts[points - 1] + " cleave / " + shockwaveRadii[points - 1] + "-unit shockwave).";
	} else {
		description = "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).";
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayAncientWisdomPopup() {
	var skillName = 'Ancient Wisdom';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
	var increases = [5, 4, 3, 2, 1]; // Diminishing returns
	var currentBenefit = 0;
	for (var i = 0; i < points; i++) {
		currentBenefit += increases[i];
	}
	var description = '';
	if (points < maxPoints) {
		var nextIncrease = increases[points];
		if (points === 0) {
			description = 'Increases elemental critical hit chance by 5%.';
		} else {
			description = 'Increases elemental critical hit chance by ' + nextIncrease + '% (Currently ' + currentBenefit + '%).';
		}
	} else {
		description = 'Maximum rank reached. Increases elemental critical hit chance by 15%.';
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayElementalMasteryPopup() {
	var skillName = 'Elemental Mastery';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
	var increases = [10, 8, 6, 4, 2]; // Diminishing returns
	var currentBenefit = 0;
	for (var i = 0; i < points; i++) {
		currentBenefit += increases[i];
	}
	var description = '';
	if (points < maxPoints) {
		var nextIncrease = increases[points];
		if (points === 0) {
			description = 'Increases elemental damage by 10%.';
		} else {
			description = 'Increases elemental damage by ' + nextIncrease + '% (Currently ' + currentBenefit + '%).';
		}
	} else {
		description = 'Maximum rank reached. Increases elemental damage by 30%.';
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayWarriorSpiritPopup() {
	var skillName = 'Warrior Spirit';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
	var increases = [10, 8, 6, 4, 2]; // Diminishing returns
	var currentBenefit = 0;
	for (var i = 0; i < points; i++) {
		currentBenefit += increases[i];
	}
	var description = '';
	if (points < maxPoints) {
		var nextIncrease = increases[points];
		if (points === 0) {
			description = 'Increases melee attack speed by 10%.';
		} else {
			description = 'Increases melee attack speed by ' + nextIncrease + '% (Currently ' + currentBenefit + '%).';
		}
	} else {
		description = 'Maximum rank reached. Increases melee attack speed by 30%.';
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayBeastTamerPopup() {
	var skillName = 'Beast Tamer';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
	var durations = [2, 3, 4, 4, 4]; // Duration in seconds
	var cooldowns = [20, 18, 16, 16, 16]; // Cooldown in seconds
	var currentDuration = 0;
	var currentCooldown = 0;
	if (points > 0) {
		currentDuration = durations[points - 1];
		currentCooldown = cooldowns[points - 1];
	}
	var description = '';
	if (points < maxPoints) {
		var nextDuration = durations[points];
		var nextCooldown = cooldowns[points];
		if (points === 0) {
			description = 'Summons a spirit beast for 2 seconds (Cooldown: 20s).';
		} else {
			description = 'Summons a spirit beast for ' + nextDuration + ' seconds (Cooldown: ' + nextCooldown + 's) (Currently ' + currentDuration + 's / ' + currentCooldown + 's).';
		}
	} else {
		description = 'Maximum rank reached. Summons a spirit beast for 4 seconds (Cooldown: 16s).';
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayHerbalRemediesPopup() {
	var skillName = 'Herbal Remedies';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
	var increases = [0.5, 0.6, 0.7, 0.8, 1.0]; // % max HP/sec
	var currentBenefit = 0;
	for (var i = 0; i < points; i++) {
		currentBenefit = increases[i];
	}
	var description = '';
	if (points < maxPoints) {
		var nextIncrease = increases[points];
		if (points === 0) {
			description = 'Heals 0.5% of max HP per second during combat.';
		} else {
			description = 'Heals ' + nextIncrease + '% per second (Currently ' + increases[points - 1] + '%).';
		}
	} else {
		description = 'Maximum rank reached. Heals 1.0% of max HP per second during combat.';
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displaySpiritGuidancePopup() {
	var skillName = 'Spirit Guidance';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
	var reductions = [5, 4, 3, 2, 1]; // Diminishing returns
	var currentBenefit = 0;
	for (var i = 0; i < points; i++) {
		currentBenefit += reductions[i];
	}
	var description = '';
	if (points < maxPoints) {
		var nextReduction = reductions[points];
		if (points === 0) {
			description = 'Reduces incoming damage by 5%.';
		} else {
			description = 'Reduces incoming damage by ' + nextReduction + '% (Currently ' + currentBenefit + '%).';
		}
	} else {
		description = 'Maximum rank reached. Reduces incoming damage by 15%.';
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function displayLegendaryAncestorPopup() {
	var skillName = 'Legendary Ancestor';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 1;
	var description = 'Temporarily increases your damage by 100% and defense by 50% for 6 seconds (Cooldown: 60s).';
	if (points >= 1) {
		description = 'Maximum rank reached. Temporarily increases your damage by 100% and defense by 50% for 6 seconds (Cooldown: 60s).';
	}
	var popup = createSkillPopup(skillName, description);
	menuContainer.addChild(popup);
	isDataSpikePopupActive = true;
}
function updateSkillPointsDisplay() {
	if (typeof skillPointsDisplay !== 'undefined') {
		skillPointsDisplay.setText('Skill Points: ' + heroSkillPoints);
	}
	if (typeof skillPointsText !== 'undefined') {
		skillPointsText.setText('Skill Points: ' + heroSkillPoints);
	}
}
updateSkillPointsDisplay(); // call once to set initial text
// Global variables
var heroSkillPoints = 3; // Starting skill points
var skillTreePointsText = null; // Will hold the text object once created
// Define refreshTreePointsText globally so it's accessible everywhere
function refreshTreePointsText() {
	if (skillTreePointsText) {
		skillTreePointsText.setText('Skill Points: ' + heroSkillPoints);
	}
}
// Function to update skill node point displays in all skill tree screens
function updateSkillNodePointDisplays() {
	// Get all currently visible skill tree containers
	var activeSkillTree = menuContainer.children.find(function (child) {
		return child instanceof Container && child.width === 2048 && child.height === 2732 && child !== skillTreePopup && child.children.some(function (c) {
			return c instanceof Text2 && c.text && c.text.includes && c.text.includes('/');
		});
	});
	if (activeSkillTree) {
		// Find all point text elements and update them
		activeSkillTree.children.forEach(function (child) {
			if (child instanceof Text2 && child.text && child.text.includes && child.text.includes('/')) {
				// Find the closest skill node to determine which skill this text belongs to
				var closestNode = null;
				var closestDistance = Infinity;
				var childPosition = {
					x: child.x,
					y: child.y
				};
				// Find the skill node icon closest to this text
				activeSkillTree.children.forEach(function (potentialNode) {
					if (potentialNode.x === child.x && Math.abs(potentialNode.y - child.y) < 200) {
						var distance = Math.abs(potentialNode.y - child.y);
						if (distance < closestDistance) {
							closestDistance = distance;
							closestNode = potentialNode;
						}
					}
				});
				// If we found a skill node, find its skill name by position
				if (closestNode) {
					var skillNodes = null;
					// Determine which skill tree we're in based on assets or titles in the tree
					if (activeSkillTree.children.some(function (c) {
						return c.texture && c.texture.baseTexture && c.texture.baseTexture.imageUrl && c.texture.baseTexture.imageUrl.includes('circuitofascension');
					})) {
						for (var skillName in skillPointAllocations) {
							if (skillPointAllocations.hasOwnProperty(skillName)) {
								var points = skillPointAllocations[skillName].points;
								var maxPoints = skillPointAllocations[skillName].max;
								// Update this specific text
								child.setText(points + '/' + maxPoints);
								break;
							}
						}
					} else {
						// Just update any text that matches the X/Y format
						if (child.text.match(/^\d+\/\d+$/)) {
							var parts = child.text.split('/');
							var skillName = null;
							// Try to find matching skill name by looping through all skill nodes positions
							for (var sName in skillPointAllocations) {
								if (skillPointAllocations.hasOwnProperty(sName)) {
									// Update with appropriate points and max
									var points = skillPointAllocations[sName].points;
									var maxPoints = skillPointAllocations[sName].max;
									child.setText(points + '/' + maxPoints);
									break;
								}
							}
						}
					}
				}
			}
		});
	}
}
var roomBackgroundImages = ['backgroundImage1', 'backgroundImage2', 'backgroundImage3', 'backgroundImage4', 'backgroundImage5'];
var arrows = [];
var currentRoom;
var visitedRooms = [];
var totalRooms = 5; // Assuming there are 5 rooms
var currentRoomMusic;
var hero;
var isPopupActive = false;
var isDataSpikePopupActive = false;
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,
		y: wallThickness
	},
	topRight: {
		x: roomWidth - wallThickness,
		y: wallThickness
	},
	bottomLeft: {
		x: wallThickness,
		y: roomHeight - wallThickness
	},
	bottomRight: {
		x: roomWidth - wallThickness,
		y: roomHeight - wallThickness
	}
};
var gameContainer = new Container();
var uiContainer = new Container();
var menuContainer = new Container();
game.addChild(gameContainer);
game.addChild(uiContainer);
game.addChild(menuContainer);
var skillTreePopup = new Container();
skillTreePopup.width = 2048;
skillTreePopup.height = 2732;
skillTreePopup.x = 0;
skillTreePopup.y = 0;
var skillTreeBackground = LK.getAsset('skillTree_Background', {
	anchorX: 0.5,
	anchorY: 0.5
});
skillTreeBackground.x = 2048 / 2;
skillTreeBackground.y = 2732 / 2;
skillTreePopup.addChild(skillTreeBackground);
// Add skill points display
var skillPointsDisplay = new Text2('Skill Points: ' + heroSkillPoints, {
	size: 70,
	fill: 0xFFFFFF,
	fontWeight: "bold"
});
skillPointsDisplay.x = 2048 / 2; // center horizontally
skillPointsDisplay.y = 2732 - 100; // near bottom
skillPointsDisplay.anchor.set(0.5, 0);
skillTreePopup.addChild(skillPointsDisplay);
var skillTrees = [{
	title: 'The Circuit of Ascension',
	theme: 'Futuristic, cybernetic evolution'
}, {
	title: 'The Echoes of Ancestry',
	theme: 'Mystical and historical'
}, {
	title: 'The Forge of Possibilities',
	theme: 'Creative and modular'
}, {
	title: 'The Prism of Potential',
	theme: 'Magical and elemental'
}, {
	title: 'The Nexus of Chaos',
	theme: 'Unpredictable and chaotic'
}, {
	title: 'The Symphony of Shadows',
	theme: 'Dark and stealth-focused'
}];
var positions = [{
	x: 1024 - 450,
	y: 1266 - 550
}, {
	x: 1024 + 450,
	y: 1266 - 550
}, {
	x: 1024 - 450,
	y: 1266
}, {
	x: 1024 + 450,
	y: 1266
}, {
	x: 1024 - 450,
	y: 1266 + 550
}, {
	x: 1024 + 450,
	y: 1266 + 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'
};
positions.forEach(function (position, index) {
	var skillTree = skillTrees[index];
	var titleText = new Text2(skillTree.title, {
		size: 50,
		fill: 0xFFFFFF,
		fontWeight: "bold",
		fontFamily: "Techno, sans-serif",
		letterSpacing: 2,
		stroke: 0x00FFCC,
		strokeThickness: 3
	});
	titleText.x = position.x;
	titleText.y = position.y + 200;
	titleText.anchor.set(0.5, 0);
	var skillTreeAssetId = skillTreeAssetMap[skillTree.title];
	var skillTreeAsset = LK.getAsset(skillTreeAssetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	if (!skillTreePopup.children.includes(skillTreeAsset)) {
		skillTreePopup.addChild(skillTreeAsset);
	}
	skillTreeAsset.x = position.x;
	skillTreeAsset.y = position.y;
	// Make the skill tree asset icon clickable
	skillTreeAsset.interactive = true;
	skillTreeAsset.down = function () {
		openSkillTreePopup(skillTree.title);
	};
	if (!skillTreePopup.children.includes(skillTreeAsset)) {
		skillTreePopup.addChild(skillTreeAsset);
	}
	// Keep the title text clickable as well
	titleText.down = function () {
		openSkillTreePopup(skillTree.title);
	};
	skillTreePopup.addChild(titleText);
});
isPopupActive = true;
menuContainer.addChild(skillTreePopup);
var testRectangle = LK.getAsset('box', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 100,
	height: 50,
	color: 0xff0000
});
testRectangle.x = 100;
testRectangle.y = 100;
skillTreePopup.addChild(testRectangle);
var startGameButton = new StartGameButton();
skillTreePopup.addChild(startGameButton);
function initializeGame() {
	currentRoom = new Room(1);
	hero.x = 2048 / 2;
	hero.y = 2732 / 2;
	updateRoomDisplay();
	playRoomMusic(currentRoom.number);
}
// Room class representing individual rooms
var Room = function Room(number) {
	this.number = number;
	this.enemies = [];
	this.isCleared = false;
	this.spawnLimit = this.number === 1 ? 29 : 12 * this.number;
	this.killGoal = this.spawnLimit;
	this.enemiesSpawned = 0;
	this.enemiesKilled = 0;
	this.enemyCounter = this.spawnLimit;
	this.init = function () {
		var self = this;
		var spawnInterval = LK.setInterval(function () {
			if (self.enemiesSpawned < self.spawnLimit && currentRoom.number === self.number && !isPopupActive) {
				self.spawnEnemy();
			} else {
				LK.clearInterval(spawnInterval);
			}
		}, 500);
	};
	this.spawnEnemy = function () {
		if (this.enemiesSpawned < this.spawnLimit && !isPopupActive && currentRoom.number === this.number) {
			var spawnKeys = Object.keys(spawnPoints);
			var spawnIndex = Math.floor(Math.random() * spawnKeys.length);
			var spawnPoint = spawnPoints[spawnKeys[spawnIndex]];
			var enemy;
			if (this.number === 1 && Math.random() < 5 / 29) {
				enemy = new TankEnemy();
			} else if (this.number === 2) {
				if (Math.random() < 10 / 40) {
					enemy = new TankEnemy();
				} else if (Math.random() < 5 / 40) {
					enemy = new RangedEnemy();
				} else {
					enemy = new Enemy();
				}
			} else {
				enemy = new Enemy();
			}
			enemy.x = spawnPoint.x;
			enemy.y = spawnPoint.y;
			enemy.active = true;
			enemy.health = 10;
			enemy.visible = true;
			this.enemies.push(enemy);
			game.addChild(enemy);
			this.enemiesSpawned++;
		}
	};
	this.init();
};
var initialBgImage = LK.getAsset('backgroundImage1', {
	anchorX: 0.5,
	anchorY: 0.5
});
initialBgImage.x = 2048 / 2;
initialBgImage.y = 2732 / 2;
game.addChildAt(initialBgImage, 0);
game.background = initialBgImage;
var statsBar = LK.getAsset('box', {
	anchorX: 0.0,
	anchorY: 0.0,
	width: 2048,
	height: 100,
	x: 0,
	y: 0
});
game.addChild(statsBar);
var roomDisplay = new Text2('Room: 1 | Enemies Left: 0', {
	size: 70,
	fill: 0xFFFFFF,
	fontWeight: "bold"
});
roomDisplay.x = 1000;
roomDisplay.y = 20;
game.addChild(roomDisplay);
function updateRoomDisplay() {
	var enemiesLeft = currentRoom.spawnLimit - currentRoom.enemiesKilled;
	roomDisplay.setText('Room: ' + currentRoom.number + ' | Enemies Left: ' + Math.max(enemiesLeft, 0));
	healthText.setText('Health: ' + hero.health);
}
function stopRoomMusic() {
	// Stop any playing music regardless of how it was started
	LK.stopMusic();
}
function playRoomMusic(roomNumber) {
	// First stop any currently playing music
	stopRoomMusic();
	// Always use LK.playMusic for consistency
	switch (roomNumber) {
		case 1:
			LK.playMusic('room1_music', {
				loop: true
			});
			break;
		case 2:
			LK.playMusic('room2_music', {
				loop: true
			});
			break;
		case 3:
			LK.playMusic('room3_music', {
				loop: true
			});
			break;
		case 4:
			LK.playMusic('room4_music', {
				loop: true
			});
			break;
		case 5:
			LK.playMusic('room5_music', {
				loop: true
			});
			break;
		default:
		// Do nothing for default case
	}
}
function checkRoomCleared() {
	if (currentRoom.enemiesKilled >= currentRoom.killGoal && !currentRoom.isCleared) {
		// Play room cleared sound
		var roomClearedSound = LK.getSound('room' + currentRoom.number + '_cleared');
		if (roomClearedSound) {
			roomClearedSound.play();
		}
		// Stop the current room's music
		stopRoomMusic();
		// Mark room as cleared and allow exit
		currentRoom.isCleared = true;
		hero.canExitRoom = true;
		updateRoomDisplay();
		addDirectionalArrows();
	}
}
function transitionToNextRoom() {
	// Remove the first call to playRoomMusic which was in the wrong place
	// Clean up the current room
	if (game.background) {
		game.removeChild(game.background);
	}
	// Clear all enemies
	currentRoom.enemies.forEach(function (enemy) {
		enemy.destroy();
	});
	currentRoom.enemies = [];
	currentRoom.enemiesSpawned = 0;
	currentRoom.enemyCounter = currentRoom.spawnLimit;
	currentRoom.enemiesKilled = 0;
	// Track visited rooms using array methods
	if (!visitedRooms.includes(currentRoom.number)) {
		visitedRooms.push(currentRoom.number);
	}
	// Find next room number
	var nextRoomNumber;
	do {
		nextRoomNumber = Math.floor(Math.random() * totalRooms) + 1;
	} while (visitedRooms.includes(nextRoomNumber) && visitedRooms.length < totalRooms);
	if (visitedRooms.length >= totalRooms) {
		// All rooms visited, reset for replayability
		visitedRooms = [];
	}
	// Initialize the new room
	currentRoom = new Room(nextRoomNumber);
	currentRoom.enemiesKilled = 0;
	// Set up background
	var bgImageIndex = (currentRoom.number - 1) % roomBackgroundImages.length;
	var bgImage = LK.getAsset(roomBackgroundImages[bgImageIndex], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bgImage.x = 2048 / 2;
	bgImage.y = 2732 / 2;
	game.addChildAt(bgImage, 0);
	game.background = bgImage;
	// Set room state
	currentRoom.isCleared = false;
	hero.canExitRoom = false;
	// Update UI
	updateRoomDisplay();
	// Play the appropriate music for the new room
	playRoomMusic(currentRoom.number);
}
function transitionToNewRoom(entrySide) {
	// Position hero based on entry side
	if (entrySide === 'top') {
		hero.y = 2732 - 10;
	} else if (entrySide === 'bottom') {
		hero.y = 10;
	} else if (entrySide === 'left') {
		hero.x = 2048 - 10;
	} else if (entrySide === 'right') {
		hero.x = 10;
	}
	// Stop current music before transitioning
	stopRoomMusic();
	// Set up the new room
	transitionToNextRoom();
	// Play music for the new room - already called inside transitionToNextRoom
	hero.canExitRoom = false;
}
var hero = gameContainer.addChild(new Hero());
hero.x = 2048 / 2;
hero.y = 2732 / 2;
var healthText = new Text2('Health: ' + hero.health, {
	size: 70,
	fill: 0xFFFFFF,
	fontWeight: "bold"
});
healthText.x = 300;
healthText.y = 20;
game.addChild(healthText);
// Movement joystick (left side)
var joystick = uiContainer.addChild(new Joystick());
joystick.x = joystick.width / 2 + 100;
joystick.y = 2732 - joystick.height / 2 - 100;
hero.joystick = joystick;
// Aiming joystick (right side)
var aimingJoystick = uiContainer.addChild(new AimingJoystick());
aimingJoystick.x = 2048 - aimingJoystick.width / 2 - 100;
aimingJoystick.y = 2732 - aimingJoystick.height / 2 - 100;
hero.aimingJoystick = aimingJoystick;
var killAllButton = LK.getAsset('killAllButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
killAllButton.x = 100;
killAllButton.y = 2732 - 350;
uiContainer.addChild(killAllButton);
killAllButton.down = function (x, y, obj) {
	if (isPopupActive || isDataSpikePopupActive) {
		return;
	}
	for (var i = currentRoom.enemies.length - 1; i >= 0; i--) {
		var enemy = currentRoom.enemies[i];
		enemy.destroy();
		currentRoom.enemies.splice(i, 1);
		currentRoom.enemiesKilled++;
	}
	updateRoomDisplay();
	checkRoomCleared();
	updateRoomDisplay();
	checkRoomCleared();
};
// Attack button removed - hero now attacks automatically
var switchWeaponZone = LK.getAsset('switchWeaponZone', {
	anchorX: 0.5,
	anchorY: 0.5
});
switchWeaponZone.x = 2048 - switchWeaponZone.width / 2;
switchWeaponZone.y = 2732 / 2;
uiContainer.addChild(switchWeaponZone);
game.down = function (x, y, obj) {
	if (isPopupActive) {
		return;
	}
	if (x >= switchWeaponZone.x - switchWeaponZone.width / 2 && x <= switchWeaponZone.x + switchWeaponZone.width / 2 && y >= switchWeaponZone.y - switchWeaponZone.height / 2 && y <= switchWeaponZone.y + switchWeaponZone.height / 2) {
		hero.weaponType = hero.weaponType === 1 ? 2 : 1;
		hero.swordGraphics.visible = hero.weaponType === 1;
		hero.bowGraphics.visible = hero.weaponType === 2;
		return;
	}
};
game.update = function () {
	if (isPopupActive) {
		return;
	}
	// We now handle movement inside hero.update() rather than here
	hero.update();
	if (hero.health <= 0) {
		hero.health = 0;
		LK.showGameOver();
		return;
	}
	if (hero.canExitRoom) {
		if (hero.y < 10 || hero.y > 2732 - 10 || hero.x < 10 || hero.x > 2048 - 10) {
			var entrySide = hero.y < 10 ? 'bottom' : hero.y > 2732 - 10 ? 'top' : hero.x < 10 ? 'right' : 'left';
			transitionToNewRoom(entrySide);
		}
	}
	// Update arrows
	for (var j = arrows.length - 1; j >= 0; j--) {
		arrows[j].update();
		for (var i = currentRoom.enemies.length - 1; i >= 0; i--) {
			var hitDx = currentRoom.enemies[i].x - arrows[j].x;
			var hitDy = currentRoom.enemies[i].y - arrows[j].y;
			var hitDist = Math.sqrt(hitDx * hitDx + hitDy * hitDy);
			if (hitDist < 60) {
				currentRoom.enemies[i].health -= arrows[j].damage;
				if (currentRoom.enemies[i].health <= 0) {
					currentRoom.enemiesKilled++;
					currentRoom.enemyCounter--;
					if (currentRoom.enemies[i].parent) {
						currentRoom.enemies[i].parent.removeChild(currentRoom.enemies[i]);
					}
					currentRoom.enemies[i].destroy();
					currentRoom.enemies.splice(i, 1);
					updateRoomDisplay();
				}
				if (arrows[j]) {
					arrows[j].destroy();
					arrows.splice(j, 1);
				}
				break;
			}
		}
	}
	// Update enemies
	if (!isPopupActive) {
		for (var k = 0; k < currentRoom.enemies.length; k++) {
			currentRoom.enemies[k].update();
		}
	}
	checkRoomCleared();
};
function createSkillPopup(skillTitle, skillDescription) {
	var skillPopup = new Container();
	skillPopup.width = 2048;
	skillPopup.height = 2732;
	skillPopup.x = 0;
	skillPopup.y = 0;
	var translucentBackground = LK.getAsset('box', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 2048,
		height: 2732,
		color: 0x000000,
		alpha: 0.5
	});
	translucentBackground.x = 2048 / 2;
	translucentBackground.y = 2732 / 2;
	skillPopup.addChild(translucentBackground);
	var skillTitleText = new Text2(skillTitle, {
		size: 120,
		fill: 0xFFFFFF,
		fontWeight: "bold",
		fontFamily: "Techno, sans-serif",
		letterSpacing: 2,
		stroke: 0x00FFCC,
		strokeThickness: 3
	});
	skillTitleText.x = 2048 / 2;
	skillTitleText.y = 2732 / 2 + 150 + 50; // Shifted down by 50 pixels
	skillTitleText.anchor.set(0.5, 0.5);
	skillPopup.addChild(skillTitleText);
	var skillDescriptionText = new Text2(skillDescription, {
		size: 80,
		fill: 0xFFFFFF,
		fontFamily: "Arial, sans-serif",
		letterSpacing: 1,
		stroke: 0x00FFCC,
		strokeThickness: 2,
		wordWrap: true,
		wordWrapWidth: 1800
	});
	skillDescriptionText.x = 2048 / 2;
	skillDescriptionText.y = skillTitleText.y + 300; // Position relative to shifted title
	skillDescriptionText.anchor.set(0.5, 0.5);
	skillPopup.addChild(skillDescriptionText);
	// Add skill point allocation counter if this skill has allocation tracking
	if (skillPointAllocations[skillTitle]) {
		var points = skillPointAllocations[skillTitle].points;
		var maxPoints = skillPointAllocations[skillTitle].max;
		var allocationText = new Text2(points + '/' + maxPoints, {
			size: 80,
			fill: 0xFFFFFF,
			fontWeight: "bold",
			stroke: 0x00FFCC,
			strokeThickness: 2
		});
		allocationText.x = 2048 / 2;
		allocationText.y = skillTitleText.y + 500; // Position below description
		allocationText.anchor.set(0.5, 0.5);
		allocationText.name = skillTitle + "_allocation"; // Add a name for easier finding
		skillPopup.addChild(allocationText);
	}
	var exitButton = LK.getAsset('cancelButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 3,
		scaleY: 3
	});
	exitButton.x = 2048 / 2 - 600;
	exitButton.y = 2732 / 2 + 950; // Shifted down by 100 pixels
	exitButton.down = function () {
		menuContainer.removeChild(skillPopup);
		isDataSpikePopupActive = false;
	};
	skillPopup.addChild(exitButton);
	var spendButton = LK.getAsset('spendButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 3,
		scaleY: 3
	});
	spendButton.x = 2048 / 2 + 600;
	spendButton.y = 2732 / 2 + 950; // Shifted down by 100 pixels
	function refreshSkillPointsText() {
		if (typeof skillPointsDisplay !== 'undefined') {
			skillPointsDisplay.setText('Skill Points: ' + heroSkillPoints);
		}
		if (typeof skillPointsText !== 'undefined') {
			skillPointsText.setText('Skill Points: ' + heroSkillPoints);
		}
	}
	spendButton.down = function () {
		if (heroSkillPoints > 0 && skillPointAllocations[skillTitle] && skillPointAllocations[skillTitle].points < skillPointAllocations[skillTitle].max) {
			heroSkillPoints--;
			refreshSkillPointsText(); // Update text after spending
			refreshTreePointsText(); // Update tree points text if visible
			// Increment the skill's points
			skillPointAllocations[skillTitle].points++;
			// Update the current popup to show the new point allocation
			var pointsElement = skillPopup.children.find(function (child) {
				return child instanceof Text2 && child.text && child.text.includes && child.text.includes('/') && child.y > skillPopup.height / 2;
			});
			if (pointsElement) {
				var points = skillPointAllocations[skillTitle].points;
				var maxPoints = skillPointAllocations[skillTitle].max;
				pointsElement.setText(points + '/' + maxPoints);
			}
			// Update all skill node point displays in any open skill tree
			updateSkillNodePointDisplays();
			// Handle skills with diminishing returns descriptions
			if (skillTitle === 'Data Spike') {
				dataSpikePoints = skillPointAllocations[skillTitle].points;
				// Close this popup and reopen it with updated description
				menuContainer.removeChild(skillPopup);
				isDataSpikePopupActive = false;
				displayDataSpikePopup();
				return; // Exit early since we're reopening the popup
			} else if (skillTitle === 'Reflex Accelerator') {
				// Close this popup and reopen it with updated description
				menuContainer.removeChild(skillPopup);
				isDataSpikePopupActive = false;
				displayReflexAcceleratorPopup();
				return; // Exit early since we're reopening the popup
			} else if (skillTitle === 'Overclock Core') {
				// Close this popup and reopen it with updated description
				menuContainer.removeChild(skillPopup);
				isDataSpikePopupActive = false;
				displayOverclockCorePopup();
				return; // Exit early since we're reopening the popup
			} else if (skillTitle === 'Neural Hijack') {
				// Close this popup and reopen it with updated description
				menuContainer.removeChild(skillPopup);
				isDataSpikePopupActive = false;
				displayNeuralHijackPopup();
				return; // Exit early since we're reopening the popup
			} else if (skillTitle === 'Dodge Matrix') {
				// Close this popup and reopen it with updated description
				menuContainer.removeChild(skillPopup);
				isDataSpikePopupActive = false;
				displayDodgeMatrixPopup();
				return; // Exit early since we're reopening the popup
			} else if (skillTitle === 'Power Surge') {
				// Close this popup and reopen it with updated description
				menuContainer.removeChild(skillPopup);
				isDataSpikePopupActive = false;
				displayPowerSurgePopup();
				return; // Exit early since we're reopening the popup
			}
			// For all other skills, just update the counter
			menuContainer.removeChild(skillPopup);
			isDataSpikePopupActive = false;
			// Re-create the popup with the updated skill points count
			// Dynamically call the correct popup function for Echoes of Ancestry skills
			if (skillTitle === 'Ancient Wisdom') {
				displayAncientWisdomPopup();
			} else if (skillTitle === 'Elemental Mastery') {
				displayElementalMasteryPopup();
			} else if (skillTitle === 'Warrior Spirit') {
				displayWarriorSpiritPopup();
			} else if (skillTitle === 'Beast Tamer') {
				displayBeastTamerPopup();
			} else if (skillTitle === 'Herbal Remedies') {
				displayHerbalRemediesPopup();
			} else if (skillTitle === 'Spirit Guidance') {
				displaySpiritGuidancePopup();
			} else if (skillTitle === 'Legendary Ancestor') {
				displayLegendaryAncestorPopup();
			} else {
				// fallback for all other skills
				var updatedPopup = createSkillPopup(skillTitle, skillDescription);
				menuContainer.addChild(updatedPopup);
			}
		} else {
			// No skill points left, optionally do nothing
		}
	};
	skillPopup.addChild(spendButton);
	var skillPointsText = new Text2('Skill Points: ' + heroSkillPoints, {
		size: 70,
		fill: 0xFFFFFF,
		fontWeight: "bold"
	});
	skillPointsText.x = 2048 / 2;
	skillPointsText.y = 2732 - 100; // bottom area of popup
	skillPointsText.anchor.set(0.5, 0);
	skillPopup.addChild(skillPointsText);
	return skillPopup;
}
function displayOverloadBlastPopup() {
	var skillName = 'Overload Blast';
	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 1;
	var description = '';
	if (points < maxPoints) {
		description = 'Unleashes a massive explosion, dealing 300% fire damage to all enemies in the room (Cooldown: 60s).';
	} else {
		description = 'Maximum rank reached. Unleashes a massive explosion, dealing 300% fire damage to all enemies in the room (Cooldown: 60s).';
	}
	var overloadBlastPopup = createSkillPopup(skillName, description);
	menuContainer.addChild(overloadBlastPopup);
	isDataSpikePopupActive = true;
}
function displayPowerSurgePopup() {
	var skillName = 'Power Surge';
	var points = skillPointAllocations[skillName].points;
	var maxPoints = skillPointAllocations[skillName].max;
	// Define scaling values for each rank
	var damageMultipliers = [1.0, 1.25, 1.5, 1.75, 2.0]; // Damage multiplier at each rank
	var radiusSizes = [2.0, 2.5, 3.0, 3.5, 4.0]; // Radius size at each rank
	// Calculate current benefits based on points already allocated
	var currentDamageMultiplier = 0;
	var currentRadius = 0;
	if (points > 0) {
		currentDamageMultiplier = damageMultipliers[points - 1];
		currentRadius = radiusSizes[points - 1];
	}
	// Prepare description based on points allocated
	var description = '';
	if (points < maxPoints) {
		var nextDamageMultiplier = damageMultipliers[points];
		var nextRadius = radiusSizes[points];
		if (points === 0) {
			description = 'Releases an energy burst dealing 100% magic damage in a 2.0-unit radius.';
		} else {
			description = 'Deals ' + nextDamageMultiplier * 100 + '% magic damage in a ' + nextRadius + '-unit radius (Currently ' + currentDamageMultiplier * 100 + '% / ' + currentRadius + ')';
		}
	} else {
		description = 'Maximum rank reached. Your energy burst deals 175% magic damage in a 3.5-unit radius.';
	}
	var powerSurgePopup = createSkillPopup(skillName, description);
	menuContainer.addChild(powerSurgePopup);
	isDataSpikePopupActive = true;
}
function displayDodgeMatrixPopup() {
	var skillName = 'Dodge Matrix';
	var points = skillPointAllocations[skillName].points;
	var maxPoints = skillPointAllocations[skillName].max;
	// Define diminishing returns values
	var dodgeIncreases = [10, 8, 6, 4, 2]; // Diminishing returns
	// Calculate current benefit based on points already allocated
	var currentBenefit = 0;
	for (var i = 0; i < points; i++) {
		currentBenefit += dodgeIncreases[i];
	}
	// Prepare description based on points allocated
	var description = '';
	if (points < maxPoints) {
		var nextIncrease = dodgeIncreases[points];
		if (points === 0) {
			description = 'Grants a 10% chance to dodge enemy attacks.';
		} else {
			description = 'Grants an ' + nextIncrease + '% chance to dodge enemy attacks (Currently ' + currentBenefit + '%)';
		}
	} else {
		description = 'Maximum rank reached. Your chance to dodge enemy attacks is increased by 30%.';
	}
	var dodgeMatrixPopup = createSkillPopup(skillName, description);
	menuContainer.addChild(dodgeMatrixPopup);
	isDataSpikePopupActive = true;
}
function displayNeuralHijackPopup() {
	var skillName = 'Neural Hijack';
	var points = skillPointAllocations[skillName].points;
	var maxPoints = skillPointAllocations[skillName].max;
	// Define diminishing returns values
	var durationIncreases = [3, 4, 5, 6, 8]; // Seconds duration
	var cooldownDecreases = [30, 27, 24, 21, 15]; // Seconds cooldown
	// Calculate current benefits based on points already allocated
	var currentDuration = 0;
	var currentCooldown = 0;
	if (points > 0) {
		currentDuration = durationIncreases[points - 1];
		currentCooldown = cooldownDecreases[points - 1];
	}
	// Prepare description based on points allocated
	var description = '';
	if (points < maxPoints) {
		var nextDuration = durationIncreases[points];
		var nextCooldown = cooldownDecreases[points];
		if (points === 0) {
			description = 'Temporarily converts an enemy to fight for you for ' + nextDuration + ' seconds (Cooldown: ' + nextCooldown + 's).';
		} else {
			description = 'Converts an enemy for ' + nextDuration + ' seconds (Cooldown: ' + nextCooldown + 's) (Currently ' + currentDuration + 's / ' + currentCooldown + 's).';
		}
	} else {
		description = 'Maximum rank reached. Converts an enemy to fight for you for 8 seconds with a 15 second cooldown.';
	}
	var neuralHijackPopup = createSkillPopup(skillName, description);
	menuContainer.addChild(neuralHijackPopup);
	isDataSpikePopupActive = true;
}
function displayOverclockCorePopup() {
	var skillName = 'Overclock Core';
	var points = skillPointAllocations[skillName].points;
	var maxPoints = skillPointAllocations[skillName].max;
	// Define diminishing returns values
	var attackSpeedIncreases = [2.5, 2.0, 1.5, 1.0, 0.5]; // Diminishing returns for attack speed
	var energyRegenIncreases = [2.0, 1.6, 1.2, 0.8, 0.4]; // Diminishing returns for energy regen
	// Calculate current benefits based on points already allocated
	var currentAttackSpeedBenefit = 0;
	var currentEnergyRegenBenefit = 0;
	for (var i = 0; i < points; i++) {
		currentAttackSpeedBenefit += attackSpeedIncreases[i];
		currentEnergyRegenBenefit += energyRegenIncreases[i];
	}
	// Prepare description based on points allocated
	var description = '';
	if (points < maxPoints) {
		var nextAttackSpeedIncrease = attackSpeedIncreases[points];
		var nextEnergyRegenIncrease = energyRegenIncreases[points];
		if (points === 0) {
			description = 'Increases attack speed by ' + nextAttackSpeedIncrease + '% and energy regeneration by ' + nextEnergyRegenIncrease + '%.';
		} else {
			description = 'Increases attack speed by ' + nextAttackSpeedIncrease + '% and energy regeneration by ' + nextEnergyRegenIncrease + '% (Currently ' + currentAttackSpeedBenefit.toFixed(1) + '% / ' + currentEnergyRegenBenefit.toFixed(1) + '%).';
		}
	} else {
		description = 'Maximum rank reached. Your attack speed is increased by 7.5% and energy regeneration by 6.0%.';
	}
	var overclockCorePopup = createSkillPopup(skillName, description);
	menuContainer.addChild(overclockCorePopup);
	isDataSpikePopupActive = true;
}
function displayReflexAcceleratorPopup() {
	var skillName = 'Reflex Accelerator';
	var points = skillPointAllocations[skillName].points;
	var maxPoints = skillPointAllocations[skillName].max;
	// Define diminishing returns values
	var speedIncreases = [10, 8, 6, 4, 2]; // Diminishing returns
	// Calculate current benefit based on points already allocated
	var currentBenefit = 0;
	for (var i = 0; i < points; i++) {
		currentBenefit += speedIncreases[i];
	}
	// Prepare description based on points allocated
	var description = '';
	if (points < maxPoints) {
		var nextIncrease = speedIncreases[points];
		if (points === 0) {
			description = 'Boosts movement speed by 10% for the first point.';
		} else {
			description = 'Boosts movement speed by ' + nextIncrease + '% (Currently ' + currentBenefit + '%)';
		}
	} else {
		description = 'Maximum rank reached. Your movement speed is increased by 30%.';
	}
	var reflexAcceleratorPopup = createSkillPopup(skillName, description);
	menuContainer.addChild(reflexAcceleratorPopup);
	isDataSpikePopupActive = true;
}
// Track skill point allocation for all skills
var dataSpikePoints = 0;
var dataSpikeMaxPoints = 5;
var dataSpikeIncreases = [5, 4, 3, 2, 1]; // Diminishing returns
// Track skill point allocations for all skill trees
var skillPointAllocations = {
	// Circuit of Ascension
	'Data Spike': {
		points: 0,
		max: 5
	},
	'Reflex Accelerator': {
		points: 0,
		max: 5
	},
	'Overclock Core': {
		points: 0,
		max: 5
	},
	'Neural Hijack': {
		points: 0,
		max: 5
	},
	'Dodge Matrix': {
		points: 0,
		max: 5
	},
	'Power Surge': {
		points: 0,
		max: 5
	},
	'Overload Blast': {
		points: 0,
		max: 1
	},
	// Echoes of Ancestry
	'Ancient Wisdom': {
		points: 0,
		max: 5
	},
	'Elemental Mastery': {
		points: 0,
		max: 5
	},
	'Warrior Spirit': {
		points: 0,
		max: 5
	},
	'Beast Tamer': {
		points: 0,
		max: 5
	},
	'Herbal Remedies': {
		points: 0,
		max: 5
	},
	'Spirit Guidance': {
		points: 0,
		max: 5
	},
	'Legendary Ancestor': {
		points: 0,
		max: 1
	},
	// Forge of Possibilities
	'Adaptive Construction': {
		points: 0,
		max: 5
	},
	'Elemental Infusion': {
		points: 0,
		max: 5
	},
	'Modular Enhancement': {
		points: 0,
		max: 5
	},
	'Resourceful Salvage': {
		points: 0,
		max: 5
	},
	'Hybrid Crafting': {
		points: 0,
		max: 5
	},
	'Runic Slots': {
		points: 0,
		max: 5
	},
	'Masterwork Creation': {
		points: 0,
		max: 5
	},
	// Prism of Potential
	'Red Radiance': {
		points: 0,
		max: 5
	},
	'Blue Bulwark': {
		points: 0,
		max: 5
	},
	'Green Growth': {
		points: 0,
		max: 5
	},
	'Yellow Zephyr': {
		points: 0,
		max: 5
	},
	'Indigo Insight': {
		points: 0,
		max: 5
	},
	'Chromatic Fusion': {
		points: 0,
		max: 5
	},
	'Prismatic Ascendance': {
		points: 0,
		max: 5
	},
	// Nexus of Chaos
	'Chaotic Spark': {
		points: 0,
		max: 5
	},
	'Entropy Shield': {
		points: 0,
		max: 5
	},
	'Unstable Rift': {
		points: 0,
		max: 5
	},
	'Anomaly Shift': {
		points: 0,
		max: 5
	},
	'Cascade of Disorder': {
		points: 0,
		max: 5
	},
	'Fractured Fate': {
		points: 0,
		max: 5
	},
	'Reality Collapse': {
		points: 0,
		max: 5
	},
	// Symphony of Shadows
	'Whispered Steps': {
		points: 0,
		max: 5
	},
	'Nightfall Veil': {
		points: 0,
		max: 5
	},
	'Serrated Shade': {
		points: 0,
		max: 5
	},
	'Shadow Familiar': {
		points: 0,
		max: 5
	},
	'Muffled Strikes': {
		points: 0,
		max: 5
	},
	'Umbral Echoes': {
		points: 0,
		max: 5
	},
	'Midnight Crescendo': {
		points: 0,
		max: 5
	}
};
function displayDataSpikePopup() {
	var currentBenefit = 0;
	// Calculate current benefit based on points allocated
	for (var i = 0; i < dataSpikePoints; i++) {
		currentBenefit += dataSpikeIncreases[i];
	}
	// Show next increase if not maxed
	var description = '';
	if (dataSpikePoints < dataSpikeMaxPoints) {
		var nextIncrease = dataSpikeIncreases[dataSpikePoints];
		if (dataSpikePoints === 0) {
			description = 'Increases critical strike chance by 5%';
		} else {
			description = 'Increases critical strike chance by ' + nextIncrease + '%. (Currently ' + currentBenefit + '%)';
		}
	} else {
		description = 'Maximum rank reached. Your critical hit chance is increased by 15%.';
	}
	var dataSpikePopup = createSkillPopup('Data Spike', description);
	menuContainer.addChild(dataSpikePopup);
	isDataSpikePopupActive = true;
}
function openSkillTreePopup(skillTreeName) {
	menuContainer.removeChild(skillTreePopup);
	var newPopup = new Container();
	newPopup.width = 2048;
	newPopup.height = 2732;
	newPopup.x = 0;
	newPopup.y = 0;
	var newPopupBackground = LK.getAsset('skillTree_Background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	newPopupBackground.x = 2048 / 2;
	newPopupBackground.y = 2732 / 2;
	newPopup.addChild(newPopupBackground);
	if (skillTreeName === 'The Circuit of Ascension') {
		var circuitAsset = LK.getAsset('popup_circuitofascension', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		circuitAsset.x = 2048 / 2;
		circuitAsset.y = 2732 / 2;
		newPopup.addChild(circuitAsset);
		var backButton = new BackButton();
		newPopup.addChild(backButton);
		var skillNodes = [{
			id: 'data_spike_icon',
			x: 2048 / 4 - 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Data Spike'
		}, {
			id: 'reflex_accelerator_icon',
			x: 2048 / 2,
			y: 2732 / 6 - 50 + 100,
			name: 'Reflex Accelerator'
		}, {
			id: 'overclock_core_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Overclock Core'
		}, {
			id: 'neural_hijack_icon',
			x: 2048 / 4 - 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Neural Hijack'
		}, {
			id: 'dodge_matrix_icon',
			x: 2048 / 2,
			y: 2 * 2732 / 6 + 100,
			name: 'Dodge Matrix'
		}, {
			id: 'power_surge_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Power Surge'
		}, {
			id: 'overload_blast_icon',
			x: 2048 / 2,
			y: 3 * 2732 / 6 + 50 + 100,
			name: 'Overload Blast'
		}];
		skillNodes.forEach(function (node) {
			var skillNode = LK.getAsset(node.id, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 3,
				scaleY: 3
			});
			skillNode.x = node.x;
			skillNode.y = node.y;
			// Add skill point allocation text below each node
			var points = skillPointAllocations[node.name] ? skillPointAllocations[node.name].points : 0;
			var maxPoints = skillPointAllocations[node.name] ? skillPointAllocations[node.name].max : 5;
			var pointsText = new Text2(points + '/' + maxPoints, {
				size: 60,
				fill: 0xFFFFFF,
				fontWeight: "bold"
			});
			pointsText.x = node.x;
			pointsText.y = node.y + 150;
			pointsText.anchor.set(0.5, 0);
			pointsText.alpha = 1; // Ensure text is visible and large enough
			newPopup.addChild(pointsText);
			// Create a node representation for the skillNode
			var nodeCircle = LK.getAsset('glowing_line_asset', {
				anchorX: 0.5,
				anchorY: 0.5,
				width: 60,
				height: 60,
				color: 0xc05bf1
			});
			nodeCircle.x = node.x;
			nodeCircle.y = node.y;
			newPopup.addChildAt(nodeCircle, 0); // Add below the skill icon
			skillNode.down = function () {
				if (isDataSpikePopupActive) {
					return;
				}
				if (node.name === 'Data Spike') {
					displayDataSpikePopup();
					isDataSpikePopupActive = true;
				} else if (node.name === 'Overclock Core') {
					displayOverclockCorePopup();
					isDataSpikePopupActive = true;
				} else if (node.name === 'Reflex Accelerator') {
					displayReflexAcceleratorPopup();
					isDataSpikePopupActive = true;
				} else if (node.name === 'Neural Hijack') {
					displayNeuralHijackPopup();
					isDataSpikePopupActive = true;
				} else if (node.name === 'Dodge Matrix') {
					displayDodgeMatrixPopup();
					isDataSpikePopupActive = true;
				} else if (node.name === 'Power Surge') {
					displayPowerSurgePopup();
					isDataSpikePopupActive = true;
				} else if (node.name === 'Overload Blast') {
					displayOverloadBlastPopup();
					isDataSpikePopupActive = true;
				}
				var originalColor = skillNode.tint;
				skillNode.tint = 0xffff00;
				LK.setTimeout(function () {
					skillNode.tint = originalColor;
				}, 1000);
			};
			newPopup.addChild(skillNode);
		});
	} else if (skillTreeName === 'The Echoes of Ancestry') {
		var ancestryAsset = LK.getAsset('popup_echoesofancestry', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		ancestryAsset.x = 2048 / 2;
		ancestryAsset.y = 2732 / 2;
		newPopup.addChild(ancestryAsset);
		var backButton = new BackButton();
		newPopup.addChild(backButton);
		var skillNodes = [{
			id: 'ancient_wisdom_icon',
			x: 2048 / 4 - 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Ancient Wisdom'
		}, {
			id: 'elemental_mastery_icon',
			x: 2048 / 2,
			y: 2732 / 6 - 50 + 100,
			name: 'Elemental Mastery'
		}, {
			id: 'warrior_spirit_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Warrior Spirit'
		}, {
			id: 'beast_tamer_icon',
			x: 2048 / 4 - 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Beast Tamer'
		}, {
			id: 'herbal_remedies_icon',
			x: 2048 / 2,
			y: 2 * 2732 / 6 + 100,
			name: 'Herbal Remedies'
		}, {
			id: 'spirit_guidance_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Spirit Guidance'
		}, {
			id: 'legendary_ancestor_icon',
			x: 2048 / 2,
			y: 3 * 2732 / 6 + 50 + 100,
			name: 'Legendary Ancestor'
		}];
		skillNodes.forEach(function (node) {
			var skillNode = LK.getAsset(node.id, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 3,
				scaleY: 3
			});
			skillNode.x = node.x;
			skillNode.y = node.y;
			// Add skill point allocation text below each node
			var points = skillPointAllocations[node.name] ? skillPointAllocations[node.name].points : 0;
			var maxPoints = skillPointAllocations[node.name] ? skillPointAllocations[node.name].max : 5;
			var pointsText = new Text2(points + '/' + maxPoints, {
				size: 60,
				fill: 0xFFFFFF,
				fontWeight: "bold"
			});
			pointsText.x = node.x;
			pointsText.y = node.y + 150;
			pointsText.anchor.set(0.5, 0);
			pointsText.alpha = 1; // Ensure text is visible
			newPopup.addChild(pointsText);
			// Create a node representation for the skillNode
			var nodeCircle = LK.getAsset('glowing_line_asset', {
				anchorX: 0.5,
				anchorY: 0.5,
				width: 60,
				height: 60,
				color: 0xc05bf1
			});
			nodeCircle.x = node.x;
			nodeCircle.y = node.y;
			newPopup.addChildAt(nodeCircle, 0); // Add below the skill icon
			skillNode.down = function () {
				if (isDataSpikePopupActive) {
					return;
				}
				if (node.name === 'Ancient Wisdom') {
					displayAncientWisdomPopup();
				} else if (node.name === 'Elemental Mastery') {
					displayElementalMasteryPopup();
				} else if (node.name === 'Warrior Spirit') {
					displayWarriorSpiritPopup();
				} else if (node.name === 'Beast Tamer') {
					displayBeastTamerPopup();
				} else if (node.name === 'Herbal Remedies') {
					displayHerbalRemediesPopup();
				} else if (node.name === 'Spirit Guidance') {
					displaySpiritGuidancePopup();
				} else if (node.name === 'Legendary Ancestor') {
					displayLegendaryAncestorPopup();
				}
				isDataSpikePopupActive = true;
			};
			newPopup.addChild(skillNode);
		});
	} else if (skillTreeName === 'The Forge of Possibilities') {
		var forgeAsset = LK.getAsset('popup_forgeofpossibilities', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		forgeAsset.x = 2048 / 2;
		forgeAsset.y = 2732 / 2;
		newPopup.addChild(forgeAsset);
		var backButton = new BackButton();
		newPopup.addChild(backButton);
		var skillNodes = [{
			id: 'adaptive_construction_icon',
			x: 2048 / 4 - 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Adaptive Construction'
		}, {
			id: 'elemental_infusion_icon',
			x: 2048 / 2,
			y: 2732 / 6 - 50 + 100,
			name: 'Elemental Infusion'
		}, {
			id: 'modular_enhancement_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Modular Enhancement'
		}, {
			id: 'resourceful_salvage_icon',
			x: 2048 / 4 - 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Resourceful Salvage'
		}, {
			id: 'hybrid_crafting_icon',
			x: 2048 / 2,
			y: 2 * 2732 / 6 + 100,
			name: 'Hybrid Crafting'
		}, {
			id: 'runic_slots_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Runic Slots'
		}, {
			id: 'masterwork_creation_icon',
			x: 2048 / 2,
			y: 3 * 2732 / 6 + 50 + 100,
			name: 'Masterwork Creation'
		}];
		skillNodes.forEach(function (node) {
			var skillNode = LK.getAsset(node.id, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 3,
				scaleY: 3
			});
			skillNode.x = node.x;
			skillNode.y = node.y;
			// Add skill point allocation text below each node
			var points = skillPointAllocations[node.name] ? skillPointAllocations[node.name].points : 0;
			var maxPoints = skillPointAllocations[node.name] ? skillPointAllocations[node.name].max : 5;
			var pointsText = new Text2(points + '/' + maxPoints, {
				size: 60,
				fill: 0xFFFFFF,
				fontWeight: "bold"
			});
			pointsText.x = node.x;
			pointsText.y = node.y + 150;
			pointsText.anchor.set(0.5, 0);
			pointsText.alpha = 1; // Ensure text is visible
			newPopup.addChild(pointsText);
			// Create a node representation for the skillNode
			var nodeCircle = LK.getAsset('glowing_line_asset', {
				anchorX: 0.5,
				anchorY: 0.5,
				width: 60,
				height: 60,
				color: 0xc05bf1
			});
			nodeCircle.x = node.x;
			nodeCircle.y = node.y;
			newPopup.addChildAt(nodeCircle, 0); // Add below the skill icon
			skillNode.down = function () {
				if (isDataSpikePopupActive) {
					return;
				}
				if (node.name === 'Adaptive Construction') {
					displayAdaptiveConstructionPopup();
				} else if (node.name === 'Elemental Infusion') {
					displayElementalInfusionPopup();
				} else if (node.name === 'Modular Enhancement') {
					displayModularEnhancementPopup();
				} else if (node.name === 'Resourceful Salvage') {
					displayResourcefulSalvagePopup();
				} else if (node.name === 'Hybrid Crafting') {
					displayHybridCraftingPopup();
				} else if (node.name === 'Runic Slots') {
					displayRunicSlotsPopup();
				} else if (node.name === 'Masterwork Creation') {
					displayMasterworkCreationPopup();
				}
				isDataSpikePopupActive = true;
			};
			newPopup.addChild(skillNode);
		});
	} else if (skillTreeName === 'The Prism of Potential') {
		var prismAsset = LK.getAsset('popup_prismofpotential', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		prismAsset.x = 2048 / 2;
		prismAsset.y = 2732 / 2;
		newPopup.addChild(prismAsset);
		var backButton = new BackButton();
		newPopup.addChild(backButton);
		var skillNodes = [{
			id: 'red_radiance_icon',
			x: 2048 / 4 - 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Red Radiance'
		}, {
			id: 'blue_bulwark_icon',
			x: 2048 / 2,
			y: 2732 / 6 - 50 + 100,
			name: 'Blue Bulwark'
		}, {
			id: 'green_growth_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Green Growth'
		}, {
			id: 'yellow_zephyr_icon',
			x: 2048 / 4 - 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Yellow Zephyr'
		}, {
			id: 'indigo_insight_icon',
			x: 2048 / 2,
			y: 2 * 2732 / 6 + 100,
			name: 'Indigo Insight'
		}, {
			id: 'chromatic_fusion_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Chromatic Fusion'
		}, {
			id: 'prismatic_ascendance_icon',
			x: 2048 / 2,
			y: 3 * 2732 / 6 + 50 + 100,
			name: 'Prismatic Ascendance'
		}];
		skillNodes.forEach(function (node) {
			var skillNode = LK.getAsset(node.id, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 3,
				scaleY: 3
			});
			skillNode.x = node.x;
			skillNode.y = node.y;
			// Add skill point allocation text below each node
			var points = skillPointAllocations[node.name] ? skillPointAllocations[node.name].points : 0;
			var maxPoints = skillPointAllocations[node.name] ? skillPointAllocations[node.name].max : 5;
			var pointsText = new Text2(points + '/' + maxPoints, {
				size: 60,
				fill: 0xFFFFFF,
				fontWeight: "bold"
			});
			pointsText.x = node.x;
			pointsText.y = node.y + 150;
			pointsText.anchor.set(0.5, 0);
			pointsText.alpha = 1; // Ensure text is visible
			newPopup.addChild(pointsText);
			// Create a node representation for the skillNode
			var nodeCircle = LK.getAsset('glowing_line_asset', {
				anchorX: 0.5,
				anchorY: 0.5,
				width: 60,
				height: 60,
				color: 0xc05bf1
			});
			nodeCircle.x = node.x;
			nodeCircle.y = node.y;
			newPopup.addChildAt(nodeCircle, 0); // Add below the skill icon
			skillNode.down = function () {
				if (isDataSpikePopupActive) {
					return;
				}
				if (node.name === 'Red Radiance') {
					displayRedRadiancePopup();
				} else if (node.name === 'Blue Bulwark') {
					displayBlueBulwarkPopup();
				} else if (node.name === 'Green Growth') {
					displayGreenGrowthPopup();
				} else if (node.name === 'Yellow Zephyr') {
					displayYellowZephyrPopup();
				} else if (node.name === 'Indigo Insight') {
					displayIndigoInsightPopup();
				} else if (node.name === 'Chromatic Fusion') {
					displayChromaticFusionPopup();
				} else if (node.name === 'Prismatic Ascendance') {
					displayPrismaticAscendancePopup();
				}
				isDataSpikePopupActive = true;
			};
			newPopup.addChild(skillNode);
		});
	} else if (skillTreeName === 'The Nexus of Chaos') {
		var nexusAsset = LK.getAsset('popup_nexusofchaos', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		nexusAsset.x = 2048 / 2;
		nexusAsset.y = 2732 / 2;
		newPopup.addChild(nexusAsset);
		var backButton = new BackButton();
		newPopup.addChild(backButton);
		var skillNodes = [{
			id: 'chaotic_spark_icon',
			x: 2048 / 4 - 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Chaotic Spark'
		}, {
			id: 'entropy_shield_icon',
			x: 2048 / 2,
			y: 2732 / 6 - 50 + 100,
			name: 'Entropy Shield'
		}, {
			id: 'unstable_rift_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Unstable Rift'
		}, {
			id: 'anomaly_shift_icon',
			x: 2048 / 4 - 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Anomaly Shift'
		}, {
			id: 'cascade_of_disorder_icon',
			x: 2048 / 2,
			y: 2 * 2732 / 6 + 100,
			name: 'Cascade of Disorder'
		}, {
			id: 'fractured_fate_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Fractured Fate'
		}, {
			id: 'reality_collapse_icon',
			x: 2048 / 2,
			y: 3 * 2732 / 6 + 50 + 100,
			name: 'Reality Collapse'
		}];
		skillNodes.forEach(function (node) {
			var skillNode = LK.getAsset(node.id, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 3,
				scaleY: 3
			});
			skillNode.x = node.x;
			skillNode.y = node.y;
			// Add skill point allocation text below each node
			var points = skillPointAllocations[node.name] ? skillPointAllocations[node.name].points : 0;
			var maxPoints = skillPointAllocations[node.name] ? skillPointAllocations[node.name].max : 5;
			var pointsText = new Text2(points + '/' + maxPoints, {
				size: 60,
				fill: 0xFFFFFF,
				fontWeight: "bold"
			});
			pointsText.x = node.x;
			pointsText.y = node.y + 150;
			pointsText.anchor.set(0.5, 0);
			pointsText.alpha = 1; // Ensure text is visible
			newPopup.addChild(pointsText);
			// Create a node representation for the skillNode
			var nodeCircle = LK.getAsset('glowing_line_asset', {
				anchorX: 0.5,
				anchorY: 0.5,
				width: 60,
				height: 60,
				color: 0xc05bf1
			});
			nodeCircle.x = node.x;
			nodeCircle.y = node.y;
			newPopup.addChildAt(nodeCircle, 0); // Add below the skill icon
			skillNode.down = function () {
				if (isDataSpikePopupActive) {
					return;
				}
				if (node.name === 'Chaotic Spark') {
					displayChaoticSparkPopup();
				} else if (node.name === 'Entropy Shield') {
					displayEntropyShieldPopup();
				} else if (node.name === 'Unstable Rift') {
					displayUnstableRiftPopup();
				} else if (node.name === 'Anomaly Shift') {
					displayAnomalyShiftPopup();
				} else if (node.name === 'Cascade of Disorder') {
					displayCascadeOfDisorderPopup();
				} else if (node.name === 'Fractured Fate') {
					displayFracturedFatePopup();
				} else if (node.name === 'Reality Collapse') {
					displayRealityCollapsePopup();
				}
				isDataSpikePopupActive = true;
			};
			newPopup.addChild(skillNode);
		});
	} else if (skillTreeName === 'The Symphony of Shadows') {
		var symphonyAsset = LK.getAsset('popup_symphonyofshadows', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		symphonyAsset.x = 2048 / 2;
		symphonyAsset.y = 2732 / 2;
		newPopup.addChild(symphonyAsset);
		var backButton = new BackButton();
		newPopup.addChild(backButton);
		var skillNodes = [{
			id: 'whispered_steps_icon',
			x: 2048 / 4 - 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Whispered Steps'
		}, {
			id: 'nightfall_veil_icon',
			x: 2048 / 2,
			y: 2732 / 6 - 50 + 100,
			name: 'Nightfall Veil'
		}, {
			id: 'serrated_shade_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2732 / 6 - 50 + 100,
			name: 'Serrated Shade'
		}, {
			id: 'shadow_familiar_icon',
			x: 2048 / 4 - 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Shadow Familiar'
		}, {
			id: 'muffled_strikes_icon',
			x: 2048 / 2,
			y: 2 * 2732 / 6 + 100,
			name: 'Muffled Strikes'
		}, {
			id: 'umbral_echoes_icon',
			x: 3 * 2048 / 4 + 50,
			y: 2 * 2732 / 6 + 100,
			name: 'Umbral Echoes'
		}, {
			id: 'midnight_crescendo_icon',
			x: 2048 / 2,
			y: 3 * 2732 / 6 + 50 + 100,
			name: 'Midnight Crescendo'
		}];
		skillNodes.forEach(function (node) {
			var skillNode = LK.getAsset(node.id, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 3,
				scaleY: 3
			});
			skillNode.x = node.x;
			skillNode.y = node.y;
			// Add skill point allocation text below each node
			var points = skillPointAllocations[node.name] ? skillPointAllocations[node.name].points : 0;
			var maxPoints = skillPointAllocations[node.name] ? skillPointAllocations[node.name].max : 5;
			var pointsText = new Text2(points + '/' + maxPoints, {
				size: 60,
				fill: 0xFFFFFF,
				fontWeight: "bold"
			});
			pointsText.x = node.x;
			pointsText.y = node.y + 150;
			pointsText.anchor.set(0.5, 0);
			pointsText.alpha = 1; // Ensure text is visible
			newPopup.addChild(pointsText);
			// Create a node representation for the skillNode
			var nodeCircle = LK.getAsset('glowing_line_asset', {
				anchorX: 0.5,
				anchorY: 0.5,
				width: 60,
				height: 60,
				color: 0xc05bf1
			});
			nodeCircle.x = node.x;
			nodeCircle.y = node.y;
			newPopup.addChildAt(nodeCircle, 0); // Add below the skill icon
			skillNode.down = function () {
				if (isDataSpikePopupActive) {
					return;
				}
				if (node.name === 'Whispered Steps') {
					displayWhisperedStepsPopup();
				} else if (node.name === 'Nightfall Veil') {
					displayNightfallVeilPopup();
				} else if (node.name === 'Serrated Shade') {
					displaySerratedShadePopup();
				} else if (node.name === 'Shadow Familiar') {
					displayShadowFamiliarPopup();
				} else if (node.name === 'Muffled Strikes') {
					displayMuffledStrikesPopup();
				} else if (node.name === 'Umbral Echoes') {
					displayUmbralEchoesPopup();
				} else if (node.name === 'Midnight Crescendo') {
					displayMidnightCrescendoPopup();
				}
				isDataSpikePopupActive = true;
			};
			newPopup.addChild(skillNode);
		});
	}
	var skillTreeTitle = new Text2(skillTreeName, {
		size: 150,
		fill: 0xFFFFFF,
		fontWeight: "bold",
		fontFamily: "Techno, sans-serif",
		letterSpacing: 2,
		stroke: 0x00FFCC,
		strokeThickness: 3
	});
	skillTreeTitle.x = 2048 / 2;
	skillTreeTitle.y = 100;
	skillTreeTitle.anchor.set(0.5, 0);
	newPopup.addChild(skillTreeTitle);
	// Create the skillTreePointsText at the bottom of the skill tree popup
	skillTreePointsText = new Text2('Skill Points: ' + heroSkillPoints, {
		size: 70,
		fill: 0xFFFFFF,
		fontWeight: "bold"
	});
	skillTreePointsText.x = 2048 / 2;
	skillTreePointsText.y = 2732 - 100; // bottom of the screen
	skillTreePointsText.anchor.set(0.5, 0);
	newPopup.addChild(skillTreePointsText);
	// Now that skillTreePointsText is defined, we can safely call refreshTreePointsText
	refreshTreePointsText();
	menuContainer.addChild(newPopup);
}

===================================================================
--- original.js
+++ change.js
@@ -708,39 +708,154 @@
 	menuContainer.addChild(popup);
 	isDataSpikePopupActive = true;
 }
 function displayAdaptiveConstructionPopup() {
-	var popup = createSkillPopup('Adaptive Construction', 'Learn to rapidly modify your weapons on the fly. Temporarily increase your sword or bow damage by 10% depending on which you wield most recently.');
+	// Firebrand Enchantment: Imbue your weapon with searing flame—each rank adds +5 % fire damage and +2 % chance to ignite on hit.
+	var skillName = 'Adaptive Construction';
+	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
+	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
+	var fireDmgPerRank = 5;
+	var ignitePerRank = 2;
+	var currentFire = points * fireDmgPerRank;
+	var currentIgnite = points * ignitePerRank;
+	var description = '';
+	if (points === 0) {
+		description = "Imbue your weapon with searing flame, adding 5% fire damage and 2% chance to ignite on hit.";
+	} else if (points < maxPoints) {
+		description = "Imbue your weapon with searing flame, adding " + (points + 1) * fireDmgPerRank + "% fire damage and " + (points + 1) * ignitePerRank + "% chance to ignite on hit (Currently " + currentFire + "% fire damage / " + currentIgnite + "% ignite).";
+	} else {
+		description = "Maximum rank reached. Imbue your weapon with searing flame, adding 25% fire damage and 10% chance to ignite on hit.";
+	}
+	var popup = createSkillPopup(skillName, description);
 	menuContainer.addChild(popup);
 	isDataSpikePopupActive = true;
 }
 function displayElementalInfusionPopup() {
-	var popup = createSkillPopup('Elemental Infusion', 'Forge special arrowheads or blade edges with elemental cores. Each successful hit has a small chance to apply a random elemental effect to enemies.');
+	// Elemental Tempo: Every swing or shot has a passive chance to inflict a random elemental effect—proc chance scales +10 %, +8 %, +6 %, +4 %, then +2 % (max 30 % at rank 5).
+	var skillName = 'Elemental Infusion';
+	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
+	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
+	var procs = [10, 8, 6, 4, 2];
+	var currentProc = 0;
+	for (var i = 0; i < points; i++) {
+		currentProc += procs[i];
+	}
+	var description = '';
+	if (points === 0) {
+		description = "Every attack has a 10% chance to inflict a random elemental effect.";
+	} else if (points < maxPoints) {
+		var nextProc = procs[points];
+		description = "Every attack has a " + (currentProc + nextProc) + "% chance to inflict a random elemental effect (Currently " + currentProc + "%).";
+	} else {
+		description = "Maximum rank reached. Every attack has a 30% chance to inflict a random elemental effect.";
+	}
+	var popup = createSkillPopup(skillName, description);
 	menuContainer.addChild(popup);
 	isDataSpikePopupActive = true;
 }
 function displayModularEnhancementPopup() {
-	var popup = createSkillPopup('Modular Enhancement', 'Attach versatile modules to your equipment. Gain a slight increase in attack speed and movement speed, allowing you to reposition more effectively during combat.');
+	// Mechanical Reflex: Bolted springs release on hit, giving you a chance to instantly ready your weapon for an extra strike—proc chance scales +3 %, +6 %, +9 %, +12 %, then +15 % (max 15 % at rank 5).
+	var skillName = 'Modular Enhancement';
+	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
+	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
+	var procs = [3, 3, 3, 3, 3]; // Actually, the example says +3, +6, +9, +12, +15, but the text says max 15% at rank 5, so let's use +3 per rank for 15% at 5.
+	var currentProc = points * 3;
+	var description = '';
+	if (points === 0) {
+		description = "Each hit has a 3% chance to instantly ready your weapon for an extra strike.";
+	} else if (points < maxPoints) {
+		description = "Each hit has a " + (points + 1) * 3 + "% chance to instantly ready your weapon for an extra strike (Currently " + currentProc + "%).";
+	} else {
+		description = "Maximum rank reached. Each hit has a 15% chance to instantly ready your weapon for an extra strike.";
+	}
+	var popup = createSkillPopup(skillName, description);
 	menuContainer.addChild(popup);
 	isDataSpikePopupActive = true;
 }
 function displayResourcefulSalvagePopup() {
-	var popup = createSkillPopup('Resourceful Salvage', 'Disassemble enemy gear after defeats. Occasionally gain a temporary buff that slightly increases your skill point gain or reduces skill cooldowns.');
+	// Resourceful Salvage: Disassemble enemy gear on kill for a small chance to siphon extra skill‑point gain—proc chance scales 2 %→6 % and buff strength/duration scales +10 % for 5 s up to +20 % for 15 s.
+	var skillName = 'Resourceful Salvage';
+	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
+	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
+	var procChances = [2, 3, 4, 5, 6];
+	var buffStrengths = [10, 12, 14, 16, 20];
+	var buffDurations = [5, 7, 9, 12, 15];
+	var currentProc = points > 0 ? procChances[points - 1] : 0;
+	var currentBuff = points > 0 ? buffStrengths[points - 1] : 0;
+	var currentDur = points > 0 ? buffDurations[points - 1] : 0;
+	var description = '';
+	if (points === 0) {
+		description = "Killing an enemy has a 2% chance to grant +10% skill‑point gain for 5 seconds.";
+	} else if (points < maxPoints) {
+		var nextProc = procChances[points];
+		var nextBuff = buffStrengths[points];
+		var nextDur = buffDurations[points];
+		description = "Killing an enemy has a " + nextProc + "% chance to grant +" + nextBuff + "% skill‑point gain for " + nextDur + " seconds (Currently " + currentProc + "% / +" + currentBuff + "% / " + currentDur + "s).";
+	} else {
+		description = "Maximum rank reached. Killing an enemy has a 6% chance to grant +20% skill‑point gain for 15 seconds.";
+	}
+	var popup = createSkillPopup(skillName, description);
 	menuContainer.addChild(popup);
 	isDataSpikePopupActive = true;
 }
 function displayHybridCraftingPopup() {
-	var popup = createSkillPopup('Hybrid Crafting', 'Blend melee and ranged weapon traits. Your arrows gain a minor cleave effect at short range, and your sword attacks have a small chance to unleash a short-ranged projectile.');
+	// Hybrid Crafting (1/1): 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.
+	var skillName = 'Hybrid Crafting';
+	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
+	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 1;
+	var description = '';
+	if (points === 0) {
+		description = "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.";
+	} else {
+		description = "Maximum rank reached. 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.";
+	}
+	var popup = createSkillPopup(skillName, description);
 	menuContainer.addChild(popup);
 	isDataSpikePopupActive = true;
 }
 function displayRunicSlotsPopup() {
-	var popup = createSkillPopup('Runic Slots', 'Add runic slots to your weapons. When you acquire elemental shards from fallen foes, socketing them grants short-term buffs like increased critical chance, armor, or life steal.');
+	// Gem Harvester: Kills can drop volatile runic gems that grant a random buff—buff potency and duration scale from +5 % for 3 s up to +15 % for 8 s, and drop chance scales 5 %→20 %.
+	var skillName = 'Runic Slots';
+	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
+	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 5;
+	var dropChances = [5, 8, 12, 16, 20];
+	var buffPotencies = [5, 7, 9, 12, 15];
+	var buffDurations = [3, 4, 5, 6, 8];
+	var currentDrop = points > 0 ? dropChances[points - 1] : 0;
+	var currentBuff = points > 0 ? buffPotencies[points - 1] : 0;
+	var currentDur = points > 0 ? buffDurations[points - 1] : 0;
+	var description = '';
+	if (points === 0) {
+		description = "Killing an enemy has a 5% chance to drop a runic gem granting a random +5% buff for 3 seconds.";
+	} else if (points < maxPoints) {
+		var nextDrop = dropChances[points];
+		var nextBuff = buffPotencies[points];
+		var nextDur = buffDurations[points];
+		description = "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 {
+		description = "Maximum rank reached. Killing an enemy has a 20% chance to drop a runic gem granting a random +15% buff for 8 seconds.";
+	}
+	var popup = createSkillPopup(skillName, description);
 	menuContainer.addChild(popup);
 	isDataSpikePopupActive = true;
 }
 function displayMasterworkCreationPopup() {
-	var popup = createSkillPopup('Masterwork Creation', 'Temporarily upgrade your weapon into a masterwork artifact. Significantly boosts both melee and ranged damage, and improves your elemental infusions for a short duration, turning you into a forging prodigy on the battlefield.');
+	// Masterwork Creation: Temporarily transform your weapon into a masterwork artifact—damage bonus, arrow‑cleave count, and shockwave radius all increase with each of 3 ranks.
+	var skillName = 'Masterwork Creation';
+	var points = skillPointAllocations[skillName] ? skillPointAllocations[skillName].points : 0;
+	var maxPoints = skillPointAllocations[skillName] ? skillPointAllocations[skillName].max : 3;
+	var dmgBonuses = [30, 60, 90];
+	var cleaveCounts = [1, 2, 3];
+	var shockwaveRadii = [1, 2, 3];
+	var description = '';
+	if (points === 0) {
+		description = "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 < 3) {
+		description = "Transforms your weapon for 6s, granting +" + dmgBonuses[points] + "% damage, arrows cleave " + cleaveCounts[points] + " extra target" + (cleaveCounts[points] > 1 ? "s" : "") + ", and melee triggers a " + shockwaveRadii[points] + "-unit shockwave (Currently +" + dmgBonuses[points - 1] + "% / " + cleaveCounts[points - 1] + " cleave / " + shockwaveRadii[points - 1] + "-unit shockwave).";
+	} else {
+		description = "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).";
+	}
+	var popup = createSkillPopup(skillName, description);
 	menuContainer.addChild(popup);
 	isDataSpikePopupActive = true;
 }
 function displayAncientWisdomPopup() {