/**** 
* Classes
****/ 
// 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.weaponType = 1;
	self.attackRange = 60;
	self.attackDamage = 10;
	self.speed = 3;
	self.joystick = null;
	self.update = function () {
		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;
		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;
		if (self.isAttacking) {
			var swingProgress = (self.attackDuration - self.attackCooldown) / 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;
			self.attackCooldown--;
			if (self.attackCooldown <= 0) {
				self.isAttacking = false;
				self.swordGraphics.rotation = 0;
			} else {
				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;
		}
	};
});
// 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;
});
// 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();
		LK.playMusic('room1_music', {
			loop: true
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Define displayLegendaryAncestorPopup function
function displayLegendaryAncestorPopup() {
	var legendaryAncestorPopup = createSkillPopup('Legendary Ancestor', 'Invoke the power of a legendary ancestor, greatly enhancing your abilities.');
	menuContainer.addChild(legendaryAncestorPopup);
	isDataSpikePopupActive = true;
}
// Define displayArcaneAlloyPopup function
function displayArcaneAlloyPopup() {
	var arcaneAlloyPopup = createSkillPopup('Arcane Alloy', 'Combine mystical elements to create a powerful alloy, enhancing your weaponry.');
	menuContainer.addChild(arcaneAlloyPopup);
	isDataSpikePopupActive = true;
}
// Define displayMetalMasteryPopup function
function displayMetalMasteryPopup() {
	var metalMasteryPopup = createSkillPopup('Metal Mastery', 'Enhance your skills in manipulating metals, increasing crafting efficiency.');
	menuContainer.addChild(metalMasteryPopup);
	isDataSpikePopupActive = true;
}
// Define displayForgeFirePopup function
function displayForgeFirePopup() {
	var forgeFirePopup = createSkillPopup('Forge Fire', 'Ignite the forge with mystical flames, enhancing your crafting abilities.');
	menuContainer.addChild(forgeFirePopup);
	isDataSpikePopupActive = true;
}
// Define displayBeastTamerPopup function
function displayBeastTamerPopup() {
	var beastTamerPopup = createSkillPopup('Beast Tamer', 'Gain the ability to tame beasts, turning them into allies.');
	menuContainer.addChild(beastTamerPopup);
	isDataSpikePopupActive = true;
}
// Define displayHerbalRemediesPopup function
function displayHerbalRemediesPopup() {
	var herbalRemediesPopup = createSkillPopup('Herbal Remedies', 'Enhance your healing abilities with natural remedies.');
	menuContainer.addChild(herbalRemediesPopup);
	isDataSpikePopupActive = true;
}
// Define displaySpiritGuidancePopup function
function displaySpiritGuidancePopup() {
	var spiritGuidancePopup = createSkillPopup('Spirit Guidance', 'Receive guidance from the spirits, enhancing your intuition and decision-making.');
	menuContainer.addChild(spiritGuidancePopup);
	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 skill nodes for each skill tree
var baseXPositions = [2048 / 4, 2048 / 2, 3 * 2048 / 4];
var tier1Y = 2732 / 6;
var tier2Y = 2 * 2732 / 6;
var tier3Y = 3 * 2732 / 6;
// Circuit of Ascension skill nodes
var circuitNodes = [{
	id: 'data_spike_icon',
	x: baseXPositions[0],
	y: tier1Y,
	name: 'Data Spike',
	action: displayDataSpikePopup
}, {
	id: 'reflex_accelerator_icon',
	x: baseXPositions[1],
	y: tier1Y,
	name: 'Reflex Accelerator',
	action: displayReflexAcceleratorPopup
}, {
	id: 'overclock_core_icon',
	x: baseXPositions[2],
	y: tier1Y,
	name: 'Overclock Core',
	action: displayOverclockCorePopup
}, {
	id: 'neural_hijack_icon',
	x: baseXPositions[0],
	y: tier2Y,
	name: 'Neural Hijack',
	action: displayNeuralHijackPopup
}, {
	id: 'dodge_matrix_icon',
	x: baseXPositions[1],
	y: tier2Y,
	name: 'Dodge Matrix',
	action: displayDodgeMatrixPopup
}, {
	id: 'brown_node_icon',
	x: baseXPositions[2],
	y: tier2Y,
	name: 'Power Surge',
	action: displayPowerSurgePopup
}, {
	id: 'ultimate_skill_icon',
	x: 2048 / 2,
	y: tier3Y,
	name: 'Overload Blast',
	action: displayOverloadBlastPopup
}];
// Echoes of Ancestry skill nodes
var ancestryNodes = [{
	id: 'data_spike_icon',
	x: baseXPositions[0],
	y: tier1Y,
	name: 'Ancient Wisdom',
	action: displayAncientWisdomPopup
}, {
	id: 'reflex_accelerator_icon',
	x: baseXPositions[1],
	y: tier1Y,
	name: 'Elemental Mastery',
	action: displayElementalMasteryPopup
}, {
	id: 'overclock_core_icon',
	x: baseXPositions[2],
	y: tier1Y,
	name: 'Warrior Spirit',
	action: displayWarriorSpiritPopup
}, {
	id: 'neural_hijack_icon',
	x: baseXPositions[0],
	y: tier2Y,
	name: 'Beast Tamer',
	action: displayBeastTamerPopup
}, {
	id: 'dodge_matrix_icon',
	x: baseXPositions[1],
	y: tier2Y,
	name: 'Herbal Remedies',
	action: displayHerbalRemediesPopup
}, {
	id: 'brown_node_icon',
	x: baseXPositions[2],
	y: tier2Y,
	name: 'Spirit Guidance',
	action: displaySpiritGuidancePopup
}, {
	id: 'ultimate_skill_icon',
	x: 2048 / 2,
	y: tier3Y,
	name: 'Legendary Ancestor',
	action: displayLegendaryAncestorPopup
}];
// Forge of Possibilities skill nodes
var forgeNodes = [{
	id: 'data_spike_icon',
	x: baseXPositions[0],
	y: tier1Y,
	name: 'Forge Fire',
	action: displayForgeFirePopup
}, {
	id: 'reflex_accelerator_icon',
	x: baseXPositions[1],
	y: tier1Y,
	name: 'Metal Mastery',
	action: displayMetalMasteryPopup
}, {
	id: 'overclock_core_icon',
	x: baseXPositions[2],
	y: tier1Y,
	name: 'Arcane Alloy',
	action: displayArcaneAlloyPopup
}, {
	id: 'neural_hijack_icon',
	x: baseXPositions[0],
	y: tier2Y,
	name: 'Runic Hammer',
	action: displayRunicHammerPopup
}, {
	id: 'dodge_matrix_icon',
	x: baseXPositions[1],
	y: tier2Y,
	name: 'Adaptive Crafting',
	action: displayAdaptiveCraftingPopup
}, {
	id: 'brown_node_icon',
	x: baseXPositions[2],
	y: tier2Y,
	name: 'Aether Furnace',
	action: displayAetherFurnacePopup
}, {
	id: 'ultimate_skill_icon',
	x: 2048 / 2,
	y: tier3Y,
	name: 'Godforge',
	action: displayGodforgePopup
}];
// Prism of Potential skill nodes
var prismNodes = [{
	id: 'data_spike_icon',
	x: baseXPositions[0],
	y: tier1Y,
	name: 'Red Fury',
	action: displayRedFuryPopup
}, {
	id: 'reflex_accelerator_icon',
	x: baseXPositions[1],
	y: tier1Y,
	name: 'Blue Shield',
	action: displayBlueShieldPopup
}, {
	id: 'overclock_core_icon',
	x: baseXPositions[2],
	y: tier1Y,
	name: 'Green Speed',
	action: displayGreenSpeedPopup
}, {
	id: 'neural_hijack_icon',
	x: baseXPositions[0],
	y: tier2Y,
	name: 'Yellow Insight',
	action: displayYellowInsightPopup
}, {
	id: 'dodge_matrix_icon',
	x: baseXPositions[1],
	y: tier2Y,
	name: 'Purple Stealth',
	action: displayPurpleStealthPopup
}, {
	id: 'brown_node_icon',
	x: baseXPositions[2],
	y: tier2Y,
	name: 'Orange Rage',
	action: displayOrangeRagePopup
}, {
	id: 'ultimate_skill_icon',
	x: 2048 / 2,
	y: tier3Y,
	name: 'White Nova',
	action: displayWhiteNovaPopup
}];
// Nexus of Chaos skill nodes
var nexusNodes = [{
	id: 'data_spike_icon',
	x: baseXPositions[0],
	y: tier1Y,
	name: 'Chaotic Bolt',
	action: displayChaoticBoltPopup
}, {
	id: 'reflex_accelerator_icon',
	x: baseXPositions[1],
	y: tier1Y,
	name: 'Entropy Field',
	action: displayEntropyFieldPopup
}, {
	id: 'overclock_core_icon',
	x: baseXPositions[2],
	y: tier1Y,
	name: 'Random Surge',
	action: displayRandomSurgePopup
}, {
	id: 'neural_hijack_icon',
	x: baseXPositions[0],
	y: tier2Y,
	name: 'Void Pull',
	action: displayVoidPullPopup
}, {
	id: 'dodge_matrix_icon',
	x: baseXPositions[1],
	y: tier2Y,
	name: 'Fractal Shield',
	action: displayFractalShieldPopup
}, {
	id: 'brown_node_icon',
	x: baseXPositions[2],
	y: tier2Y,
	name: 'Quantum Blink',
	action: displayQuantumBlinkPopup
}, {
	id: 'ultimate_skill_icon',
	x: 2048 / 2,
	y: tier3Y,
	name: 'Cosmic Collapse',
	action: displayCosmicCollapsePopup
}];
// Symphony of Shadows skill nodes
var symphonyNodes = [{
	id: 'data_spike_icon',
	x: baseXPositions[0],
	y: tier1Y,
	name: 'Shadow Blade',
	action: displayShadowBladePopup
}, {
	id: 'reflex_accelerator_icon',
	x: baseXPositions[1],
	y: tier1Y,
	name: 'Silent Step',
	action: displaySilentStepPopup
}, {
	id: 'overclock_core_icon',
	x: baseXPositions[2],
	y: tier1Y,
	name: 'Umbral Strike',
	action: displayUmbralStrikePopup
}, {
	id: 'neural_hijack_icon',
	x: baseXPositions[0],
	y: tier2Y,
	name: 'Nightmare Veil',
	action: displayNightmareVeilPopup
}, {
	id: 'dodge_matrix_icon',
	x: baseXPositions[1],
	y: tier2Y,
	name: 'Echoing Laugh',
	action: displayEchoingLaughPopup
}, {
	id: 'brown_node_icon',
	x: baseXPositions[2],
	y: tier2Y,
	name: 'Phantom Waltz',
	action: displayPhantomWaltzPopup
}, {
	id: 'ultimate_skill_icon',
	x: 2048 / 2,
	y: tier3Y,
	name: 'Final Crescendo',
	action: displayFinalCrescendoPopup
}];
// Define refreshTreePointsText globally so it's accessible everywhere
function refreshTreePointsText() {
	if (skillTreePointsText) {
		skillTreePointsText.setText('Skill Points: ' + heroSkillPoints);
	}
}
// Define displayRunicHammerPopup function
function displayRunicHammerPopup() {
	var runicHammerPopup = createSkillPopup('Runic Hammer', 'Harness the power of runes to enhance your crafting abilities.');
	menuContainer.addChild(runicHammerPopup);
	isDataSpikePopupActive = true;
}
// Define displayGodforgePopup function
function displayGodforgePopup() {
	var godforgePopup = createSkillPopup('Godforge', 'Unlock the ultimate crafting potential, allowing for the creation of legendary items.');
	menuContainer.addChild(godforgePopup);
	isDataSpikePopupActive = true;
}
// Define displayAetherFurnacePopup function
function displayAetherFurnacePopup() {
	var aetherFurnacePopup = createSkillPopup('Aether Furnace', 'Channel the power of the aether to enhance your crafting capabilities.');
	menuContainer.addChild(aetherFurnacePopup);
	isDataSpikePopupActive = true;
}
// Define displayAdaptiveCraftingPopup function
function displayAdaptiveCraftingPopup() {
	var adaptiveCraftingPopup = createSkillPopup('Adaptive Crafting', 'Adapt your crafting techniques to improve efficiency and versatility.');
	menuContainer.addChild(adaptiveCraftingPopup);
	isDataSpikePopupActive = true;
}
// Define displayAncientWisdomPopup function
function displayAncientWisdomPopup() {
	var ancientWisdomPopup = createSkillPopup('Ancient Wisdom', 'Unlocks the secrets of the ancients, enhancing your abilities.');
	menuContainer.addChild(ancientWisdomPopup);
	isDataSpikePopupActive = true;
}
// Define displayElementalMasteryPopup function
function displayElementalMasteryPopup() {
	var elementalMasteryPopup = createSkillPopup('Elemental Mastery', 'Harness the power of the elements to enhance your skills.');
	menuContainer.addChild(elementalMasteryPopup);
	isDataSpikePopupActive = true;
}
// Define displayWarriorSpiritPopup function
function displayWarriorSpiritPopup() {
	var warriorSpiritPopup = createSkillPopup('Warrior Spirit', 'Unleash the inner warrior, boosting your combat abilities.');
	menuContainer.addChild(warriorSpiritPopup);
	isDataSpikePopupActive = true;
}
var roomBackgroundImages = ['backgroundImage1', 'backgroundImage2', 'backgroundImage3', 'backgroundImage4', 'backgroundImage5'];
var arrows = [];
var currentRoom;
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: "#ffffff",
	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 - 300,
	y: 1266 - 400
}, {
	x: 1024 + 300,
	y: 1266 - 400
}, {
	x: 1024 - 300,
	y: 1266 - 50
}, {
	x: 1024 + 300,
	y: 1266 - 50
}, {
	x: 1024 - 300,
	y: 1266 + 300
}, {
	x: 1024 + 300,
	y: 1266 + 300
}];
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: "#ffffff",
		fontWeight: "bold",
		fontFamily: "Techno, sans-serif",
		letterSpacing: 2,
		stroke: "#00ffcc",
		strokeThickness: 3
	});
	titleText.x = position.x;
	titleText.y = position.y + 100;
	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;
	if (!skillTreePopup.children.includes(skillTreeAsset)) {
		skillTreePopup.addChild(skillTreeAsset);
	}
	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 ? 24 : 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 = 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: "#ffffff",
	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() {
	if (currentRoomMusic) {
		currentRoomMusic.stop();
	}
}
function playRoomMusic(roomNumber) {
	if (currentRoomMusic) {
		currentRoomMusic.stop();
	}
	switch (roomNumber) {
		case 1:
			currentRoomMusic = LK.getSound('room1_music');
			currentRoomMusic.play({
				loop: true
			});
			break;
		case 2:
			LK.playMusic('room2_music', {
				loop: true
			});
			break;
		case 3:
			LK.playMusic('room3_music', {
				loop: true
			});
			break;
		case 4:
			currentRoomMusic = LK.getSound('room4_music');
			currentRoomMusic.play({
				loop: true
			});
			break;
		case 5:
			LK.playMusic('room5_music', {
				loop: true
			});
			break;
		default:
			currentRoomMusic = null;
	}
}
function checkRoomCleared() {
	if (currentRoom.enemiesKilled >= currentRoom.killGoal && !currentRoom.isCleared) {
		var roomClearedSound = LK.getSound('room' + currentRoom.number + '_cleared');
		if (roomClearedSound) {
			roomClearedSound.play();
		}
		if (currentRoom.number === 1) {
			LK.getSound('room1_music').stop();
		} else if (currentRoom.number === 2) {
			LK.getSound('room2_music').stop();
		} else if (currentRoom.number === 3) {
			LK.getSound('room3_music').stop();
		} else if (currentRoom.number === 4) {
			currentRoomMusic.stop();
		} else if (currentRoom.number === 5) {
			currentRoomMusic.stop();
		}
		stopRoomMusic();
		currentRoom.isCleared = true;
		hero.canExitRoom = true;
		updateRoomDisplay();
	}
}
function transitionToNextRoom() {
	playRoomMusic(currentRoom.number);
	if (game.background) {
		game.removeChild(game.background);
	}
	currentRoom.enemies.forEach(function (enemy) {
		enemy.destroy();
	});
	currentRoom.enemies = [];
	currentRoom.enemiesSpawned = 0;
	currentRoom.enemyCounter = currentRoom.spawnLimit;
	currentRoom.enemiesKilled = 0;
	currentRoom = new Room(currentRoom.number + 1);
	currentRoom.enemiesKilled = 0;
	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;
	currentRoom.isCleared = false;
	hero.canExitRoom = false;
	updateRoomDisplay();
}
function transitionToNewRoom(entrySide) {
	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;
	}
	stopRoomMusic();
	transitionToNextRoom();
	playRoomMusic(currentRoom.number);
	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: "#ffffff",
	fontWeight: "bold"
});
healthText.x = 300;
healthText.y = 20;
game.addChild(healthText);
var joystick = uiContainer.addChild(new Joystick());
hero.joystick = joystick;
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();
};
var attackButton = LK.getAsset('attackIcon', {
	anchorX: 0.5,
	anchorY: 0.5
});
attackButton.x = 2048 - 150;
attackButton.y = 2732 - 300;
uiContainer.addChild(attackButton);
attackButton.down = function (x, y, obj) {
	if (isPopupActive) {
		return;
	}
	if (hero.weaponType === 1) {
		hero.isAttacking = true;
		hero.attackCooldown = hero.attackDuration;
		LK.setTimeout(function () {
			hero.swordGraphics.rotation = 0.5;
		}, hero.attackDuration * 10);
	} else if (hero.weaponType === 2) {
		var arrow = new Arrow();
		arrow.x = hero.x;
		arrow.y = hero.y;
		arrow.rotation = hero.rotation;
		arrows.push(arrow);
		game.addChild(arrow);
	}
};
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;
	}
	if (hero.joystick && !isPopupActive) {
		var direction = hero.joystick.getDirection();
		if (direction.x !== 0 || direction.y !== 0) {
			hero.x += direction.x * hero.speed;
			hero.y += direction.y * hero.speed;
			hero.rotation = Math.atan2(direction.y, direction.x);
		}
	}
	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);
		}
	}
	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;
			}
		}
	}
	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: "#ffffff",
		fontWeight: "bold",
		fontFamily: "Techno, sans-serif",
		letterSpacing: 2,
		stroke: "#00ffcc",
		strokeThickness: 3
	});
	skillTitleText.x = 2048 / 2;
	skillTitleText.y = 2732 / 2 + 150;
	skillTitleText.anchor.set(0.5, 0.5);
	skillPopup.addChild(skillTitleText);
	var skillDescriptionText = new Text2(skillDescription, {
		size: 80,
		fill: "#ffffff",
		fontFamily: "Arial, sans-serif",
		letterSpacing: 1,
		stroke: "#00ffcc",
		strokeThickness: 2,
		wordWrap: true,
		wordWrapWidth: 1800
	});
	skillDescriptionText.x = 2048 / 2;
	skillDescriptionText.y = skillTitleText.y + 150;
	skillDescriptionText.anchor.set(0.5, 0.5);
	skillPopup.addChild(skillDescriptionText);
	var exitButton = LK.getAsset('cancelButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 3,
		scaleY: 3
	});
	exitButton.x = 2048 / 2 - 600;
	exitButton.y = 2732 / 2 + 850;
	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 + 850;
	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) {
			heroSkillPoints--;
			refreshSkillPointsText(); // Update text after spending
			refreshTreePointsText(); // Update tree points text if visible
			// You can add any skill unlocking logic here if needed
		} else {
			// No skill points left, optionally do nothing
		}
	};
	skillPopup.addChild(spendButton);
	var skillPointsText = new Text2('Skill Points: ' + heroSkillPoints, {
		size: 70,
		fill: "#ffffff",
		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 overloadBlastPopup = createSkillPopup('Overload Blast', 'Unleashes a massive explosion that damages all enemies in the room.');
	menuContainer.addChild(overloadBlastPopup);
	isDataSpikePopupActive = true;
}
function displayPowerSurgePopup() {
	var powerSurgePopup = createSkillPopup('Power Surge', 'Releases an energy burst that damages all nearby enemies.');
	menuContainer.addChild(powerSurgePopup);
	isDataSpikePopupActive = true;
}
function displayDodgeMatrixPopup() {
	var dodgeMatrixPopup = createSkillPopup('Dodge Matrix', 'Grants a 10% chance to evade enemy attacks.');
	menuContainer.addChild(dodgeMatrixPopup);
	isDataSpikePopupActive = true;
}
function displayNeuralHijackPopup() {
	var neuralHijackPopup = createSkillPopup('Neural Hijack', 'Temporarily converts an enemy to fight for you.');
	menuContainer.addChild(neuralHijackPopup);
	isDataSpikePopupActive = true;
}
function displayOverclockCorePopup() {
	var overclockCorePopup = createSkillPopup('Overclock Core', 'Increases attack speed (2.5%) and energy regeneration by 2%.');
	menuContainer.addChild(overclockCorePopup);
	isDataSpikePopupActive = true;
}
function displayReflexAcceleratorPopup() {
	var reflexAcceleratorPopup = createSkillPopup('Reflex Accelerator', 'Boosts movement speed by 10%.');
	menuContainer.addChild(reflexAcceleratorPopup);
	isDataSpikePopupActive = true;
}
function displayDataSpikePopup() {
	var dataSpikePopup = createSkillPopup('Data Spike', 'Increases critical hit chance by 5%.');
	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);
	var chosenNodes;
	if (skillTreeName === 'The Circuit of Ascension') {
		chosenNodes = circuitNodes;
	} else if (skillTreeName === 'The Echoes of Ancestry') {
		chosenNodes = ancestryNodes;
	} else if (skillTreeName === 'The Forge of Possibilities') {
		chosenNodes = forgeNodes;
	} else if (skillTreeName === 'The Prism of Potential') {
		chosenNodes = prismNodes;
	} else if (skillTreeName === 'The Nexus of Chaos') {
		chosenNodes = nexusNodes;
	} else if (skillTreeName === 'The Symphony of Shadows') {
		chosenNodes = symphonyNodes;
	}
	// Add the chosen skill nodes to the popup
	addSkillNodes(chosenNodes);
	var skillTreeTitle = new Text2(skillTreeName, {
		size: 150,
		fill: "#ffffff",
		fontWeight: "bold",
		fontFamily: "Techno, sans-serif",
		letterSpacing: 2,
		stroke: "#00ffcc",
		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: "#ffffff",
		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);
}