/**** 
* Classes
****/ 
// Arrow class representing the arrows fired by the hero
var Arrow = Container.expand(function () {
	var self = Container.call(this);
	var arrowGraphics = self.attachAsset('arrow', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 15;
	self.damage = 5;
	self.update = function () {
		// Move the arrow in its current direction
		self.x += Math.cos(self.rotation) * self.speed;
		self.y += Math.sin(self.rotation) * self.speed;
		// Destroy arrow if it goes off screen
		if (self.x < 0 || self.x > 2048 || self.y < 0 || self.y > 2732) {
			self.destroy();
		}
	};
});
// CancelButton class for the cancel button asset
var CancelButton = Container.expand(function () {
	var self = Container.call(this);
	var buttonGraphics = self.attachAsset('cancelButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
// Enemy class representing the enemy character
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	// Attach the first frame of the enemy running animation
	var enemyGraphics = self.attachAsset('enemy_run1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Store animation frames
	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
	})];
	// Initialize animation and movement variables
	self.speed = 2 + Math.random() * 0.5; // Random speed between 2 and 2.5
	self.damageCooldown = 0; // Initialize damage cooldown
	var currentFrame = 0;
	var frameDelay = 30; // 500ms delay at 60FPS
	var frameCounter = 0;
	// Update function to handle animation
	self.update = function () {
		frameCounter++;
		if (frameCounter >= frameDelay) {
			frameCounter = 0;
			// Remove current frame and add the next frame
			self.removeChild(enemyGraphics);
			currentFrame = (currentFrame + 1) % frames.length;
			enemyGraphics = self.addChild(frames[currentFrame]);
		}
		// Calculate direction towards a slightly offset position around the hero
		var offsetX = (Math.random() - 0.5) * 20; // Further reduced random offset between -10 and 10
		var offsetY = (Math.random() - 0.5) * 20; // Further reduced random offset between -10 and 10
		var dx = hero.x + offsetX - self.x;
		var dy = hero.y + offsetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Normalize direction and move towards the hero
		var minDistance = 70; // Minimum distance to maintain from the hero
		if (distance > minDistance) {
			self.x += dx / distance * self.speed; // Use individual speed
			self.y += dy / distance * self.speed; // Use individual speed
			self.rotation = Math.atan2(dy, dx); // Face the hero
		} else {
			// Deal damage to the hero at regular intervals
			if (self.damageCooldown <= 0) {
				hero.health -= 5; // Deal 5 damage to the hero
				self.damageCooldown = 60; // Reset cooldown (1 second at 60FPS)
				updateRoomDisplay(); // Update health display
			} else {
				self.damageCooldown--;
			}
			// If too close, adjust position to maintain minimum distance
			self.x -= dx / distance * (minDistance - distance);
			self.y -= dy / distance * (minDistance - distance);
		}
		// Restrict movement within room boundaries
		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;
});
// Assets will be automatically created and loaded by the LK engine based on their usage in the code.
// 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
	});
	// Add a sword asset to the hero
	self.swordGraphics = heroGraphics.addChild(LK.getAsset('sword', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	// Position the sword further in front of the hero using fixed offsets
	self.swordGraphics.x = heroGraphics.width / 2 + 20; // Adjusted x position
	self.swordGraphics.y = 0;
	// Add a bow asset to the hero
	self.bowGraphics = self.attachAsset('bow', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Position the bow slightly in front of the character
	self.bowGraphics.x = heroGraphics.width / 2;
	// Hide the bow initially
	self.bowGraphics.visible = false;
	// Initialize sword attack variables
	self.attackCooldown = 0;
	self.isAttacking = false;
	self.health = 100; // Starting health
	self.attackDuration = 20; // frames
	self.weaponType = 1; // Initialize weapon type to sword
	self.attackRange = 60;
	self.attackDamage = 10;
	self.speed = 3;
	self.joystick = null; // Reference to the Joystick object
	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;
		// Restrict movement within boundaries unless at entrances
		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;
		}
		// Update hero position
		this.x = nextX;
		this.y = nextY;
		// Ensure sword follows hero's rotation
		if (self.isAttacking) {
			// Zelda-style sword swing animation with a wide arc
			var swingProgress = (self.attackDuration - self.attackCooldown) / self.attackDuration;
			self.swordGraphics.rotation = Math.sin(swingProgress * Math.PI) * 1.2; // Wider arc
			self.swordGraphics.x = heroGraphics.width / 2 + Math.cos(swingProgress * Math.PI) * 30; // Move sword in arc
			self.swordGraphics.y = Math.sin(swingProgress * Math.PI) * 30; // Move sword in arc
			self.attackCooldown--;
			if (self.attackCooldown <= 0) {
				self.isAttacking = false;
				self.swordGraphics.rotation = 0; // Reset sword position
			} else {
				// Check for collision with enemies during sword attack
				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);
							console.log("Enemy defeated by sword. Total killed: " + currentRoom.enemiesKilled);
							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);
	// Attach joystick background and handle images with centering
	var joystickBackground = self.attachAsset('joystickBackground', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var joystickHandle = self.attachAsset('joystickHandle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Position joystick in the bottom-left corner, adjusting for touch screens
	self.x = joystickBackground.width / 2 + 100;
	self.y = 2732 - joystickBackground.height / 2 - 100;
	var maxRadius = 100;
	var isDragging = false;
	// Handle dragging logic
	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
		}; // Centered joystick means no movement
	};
	return self;
});
// SpendButton class for the spend button asset
var SpendButton = Container.expand(function () {
	var self = Container.call(this);
	var buttonGraphics = self.attachAsset('spendButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});

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

/**** 
* Game Code
****/ 
// Global flag to indicate when a popup is active
var isPopupActive = false;
// Create separate containers for game, UI, and Menu elements
var gameContainer = new Container();
var uiContainer = new Container();
var menuContainer = new Container();
game.addChild(gameContainer);
game.addChild(uiContainer);
game.addChild(menuContainer);
// Create a popup container to hold the skill tree buttons
var skillTreePopup = new Container();
skillTreePopup.width = 2048;
skillTreePopup.height = 2732;
skillTreePopup.x = 0;
skillTreePopup.y = 0;
// Add a background asset to the skill tree popup
var skillTreeBackground = LK.getAsset('skillTree_Background', {
	anchorX: 0.5,
	anchorY: 0.5
});
skillTreeBackground.x = 2048 / 2;
skillTreeBackground.y = 2732 / 2;
skillTreePopup.addChild(skillTreeBackground);
// Define button properties
var buttonWidth = 300;
var buttonHeight = 100;
var buttonSpacing = 50;
var buttonYStart = 500;
// Skill tree button titles and themes
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'
}];
// Define positions for a new layout with 3 rows and 2 columns
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
}];
// Create named selections for each skill tree
skillTrees.forEach(function (skillTree, index) {
	var position = positions[index];
	// Add title text for each skill tree
	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);
	// Attach skill tree image asset to each title using static mapping
	var skillTreeAssetMap = {
		'The Circuit of Ascension': 'circuitofascension',
		'The Echoes of Ancestry': 'echoesofancestry',
		'The Forge of Possibilities': 'forgeofpossibilities',
		'The Prism of Potential': 'prismofpotential',
		'The Nexus of Chaos': 'nexusofchaos',
		'The Symphony of Shadows': 'symphonyofshadows'
	};
	var skillTreeAssetId = skillTreeAssetMap[skillTree.title];
	var skillTreeAsset = LK.getAsset(skillTreeAssetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Ensure skill tree asset is added only once
	if (!skillTreePopup.children.includes(skillTreeAsset)) {
		skillTreePopup.addChild(skillTreeAsset);
	}
	skillTreeAsset.x = position.x;
	skillTreeAsset.y = position.y;
	// Ensure skill tree asset is added only once
	if (!skillTreePopup.children.includes(skillTreeAsset)) {
		skillTreePopup.addChild(skillTreeAsset);
	}
	// Add click event to open skill tree popup
	titleText.down = function () {
		console.log("Skill tree opened: " + skillTree.title);
		openSkillTreePopup(skillTree.title);
	};
	// Add title to the popup
	skillTreePopup.addChild(titleText);
});
// Set isPopupActive to true when the skill tree popup is displayed
isPopupActive = true;
// Add the popup to the game
menuContainer.addChild(skillTreePopup);
// Define skillNodes in the global scope
// Define skillNodes in the global scope
var skillNodes = [];
// Function to check if a node can be unlocked
function canUnlockNode(node) {
	if (node.y === 2732 / 6) {
		// Tier 1 nodes
		return true;
	} else if (node.y === 2 * 2732 / 6) {
		// Tier 2 nodes
		return skillNodes.some(function (n) {
			return n.y === 2732 / 6 && !n.locked;
		});
	} else if (node.y === 3 * 2732 / 6) {
		// Tier 3 node
		return skillNodes.every(function (n) {
			return n.y === 2 * 2732 / 6 && !n.locked;
		});
	}
	return false;
}
function openSkillTreePopup(skillTreeName) {
	// Remove the current popup
	menuContainer.removeChild(skillTreePopup);
	// Create a new popup container
	var newPopup = new Container();
	newPopup.width = 2048;
	newPopup.height = 2732;
	newPopup.x = 0;
	newPopup.y = 0;
	// Add a background to the new popup
	var newPopupBackground = LK.getAsset('skillTree_Background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	newPopupBackground.x = 2048 / 2;
	newPopupBackground.y = 2732 / 2;
	newPopup.addChild(newPopupBackground);
	// Attach the specific skill tree asset on top of the background
	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.x = (2048 - newPopup.width) / 2;
		newPopup.y = (2732 - newPopup.height) / 2;
		newPopup.addChild(circuitAsset);
		// Add skill nodes
		skillNodes = [{
			id: 'data_spike_icon',
			x: 2048 / 4,
			y: 2732 / 6,
			name: 'Data Spike'
		}, {
			id: 'reflex_accelerator_icon',
			x: 2048 / 2,
			y: 2732 / 6,
			name: 'Reflex Accelerator'
		}, {
			id: 'overclock_core_icon',
			x: 3 * 2048 / 4,
			y: 2732 / 6,
			name: 'Overclock Core'
		}, {
			id: 'cybernetic_implant_icon',
			x: 2048 / 4,
			y: 2 * 2732 / 6,
			name: 'Cybernetic Implant'
		}, {
			id: 'neural_link_icon',
			x: 2048 / 2,
			y: 2 * 2732 / 6,
			name: 'Neural Link'
		}, {
			id: 'quantum_processor_icon',
			x: 3 * 2048 / 4,
			y: 2 * 2732 / 6,
			name: 'Quantum Processor'
		}, {
			id: 'ultimate_skill_icon',
			x: 2048 / 2,
			y: 3 * 2732 / 6,
			name: 'Ultimate Skill'
		}];
		skillNodes.forEach(function (node) {
			node.locked = true; // Initialize all nodes as locked
			var skillNode = LK.getAsset(node.id, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			skillNode.x = node.x;
			skillNode.y = node.y;
			skillNode.down = function () {
				console.log('Skill node ' + node.name + ' selected');
				LK.effects.flashObject(skillNode, 0xffff00, 1000); // Highlight with yellow for 1 second
				// Display confirmation popup
				displayConfirmationPopup(node, skillNode);
			};
			function displayConfirmationPopup(node, skillNode) {
				// Create a popup container
				var popup = new Container();
				popup.width = 600;
				popup.height = 400;
				popup.x = (2048 - popup.width) / 2;
				popup.y = (2732 - popup.height) / 2;
				// Add a background to the popup
				var popupBackground = LK.getAsset('box', {
					anchorX: 0.5,
					anchorY: 0.5,
					width: popup.width,
					height: popup.height,
					color: 0x333333
				});
				popup.addChild(popupBackground);
				// Add skill name and description
				var skillNameText = new Text2(node.name, {
					size: 50,
					fill: "#ffffff",
					fontWeight: "bold",
					stroke: "#00ffcc",
					strokeThickness: 3
				});
				skillNameText.x = popup.width / 2;
				skillNameText.y = 40;
				skillNameText.anchor.set(0.5, 0);
				popup.addChild(skillNameText);
				var skillDescriptionText = new Text2(getSkillDescription(node.name), {
					size: 30,
					fill: "#cccccc",
					wordWrap: true,
					wordWrapWidth: popup.width - 50
				});
				skillDescriptionText.x = popup.width / 2;
				skillDescriptionText.y = 140;
				skillDescriptionText.anchor.set(0.5, 0);
				popup.addChild(skillDescriptionText);
				// Test with different skills
				console.log('Testing displayConfirmationPopup with Data Spike');
				console.log('Testing displayConfirmationPopup with Overclock Core');
				// Add Cancel and Spend buttons
				var cancelButton = new CancelButton();
				cancelButton.x = popup.width / 3;
				cancelButton.y = popup.height - 60;
				var spendButton = new SpendButton();
				spendButton.x = 2 * popup.width / 3;
				spendButton.y = popup.height - 60;
				cancelButton.down = function () {
					console.log('Unlock canceled for ' + node.name);
					menuContainer.removeChild(popup);
				};
				popup.addChild(cancelButton);
				var spendButton = new SpendButton();
				spendButton.x = 2 * popup.width / 3;
				spendButton.down = function () {
					if (node.locked) {
						if (skillPoints > 0 && canUnlockNode(node)) {
							skillPoints--;
							skillPointsText.setText('Skill Points: ' + skillPoints);
							node.locked = false;
							console.log(node.name + ' unlock confirmed');
							LK.effects.flashObject(skillNode, 0x00ff00, 1000); // Highlight with green for 1 second
						} else if (skillPoints <= 0) {
							console.log('Not enough skill points to unlock ' + node.name);
						} else {
							console.log('Cannot unlock ' + node.name + ' - prerequisites not met.');
						}
					} else {
						console.log(node.name + ' is already unlocked');
					}
					menuContainer.removeChild(popup);
				};
				popup.addChild(spendButton);
				// Add the popup to the menu container
				menuContainer.addChild(popup);
				console.log('Skill ' + node.name + ' description viewed');
			}
			function getSkillDescription(skillName) {
				switch (skillName) {
					case 'Data Spike':
						return 'Increases critical hit chance by 5%.';
					case 'Reflex Accelerator':
						return 'Boosts movement speed by 10%.';
					case 'Overclock Core':
						return 'Increases attack speed and energy regeneration.';
					case 'Neural Hijack':
						return 'Temporarily converts an enemy to fight for you.';
					case 'Dodge Matrix':
						return 'Grants a 20% chance to evade enemy attacks.';
					case 'Power Surge':
						return 'Releases an energy burst that damages all nearby enemies.';
					case 'Overload Blast':
						return 'Unleashes a massive explosion that damages all enemies in the room.';
					default:
						return 'No description available.';
				}
			}
			console.log('Skill node ' + node.name + ' added to Row ' + (node.y === 2732 / 6 ? '1' : node.y === 2732 / 3 ? '2' : '3'));
			newPopup.addChild(skillNode);
		});
		// Connect nodes with glowing lines
		var glowingLine = LK.getAsset('glowing_line_asset', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Connect nodes within each branch
		var connectNodes = function connectNodes(node1, node2) {
			var line = LK.getAsset('glowing_line_asset', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			line.x = (node1.x + node2.x) / 2;
			line.y = (node1.y + node2.y) / 2;
			newPopup.addChild(line);
		};
		// Connect Tier 1 nodes (no Tier 2 or Tier 3 nodes to connect)
	} 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);
	} 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);
	} 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);
	} 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);
	} 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);
	}
	// Add the skill tree name at the top
	var skillTreeTitle = new Text2(skillTreeName, {
		size: 100,
		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);
	// Log the skill tree name
	console.log('Skill tree opened: ' + skillTreeName);
	// Add the new popup to the menu container
	menuContainer.addChild(newPopup);
	console.log('Skill tree layout updated for The Circuit of Ascension');
	console.log('Basic interactivity added to The Circuit of Ascension nodes');
}
function stopRoomMusic() {
	if (currentRoomMusic) {
		currentRoomMusic.stop();
	}
}
var currentRoomMusic;
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;
	}
	// Removed redundant music play call
}
function initializeFirstRoomMusic() {
	currentRoomMusic = LK.getSound('room1_music');
	currentRoomMusic.play({
		loop: true,
		fade: {
			start: 0,
			end: 1,
			duration: 1000
		}
	});
}
initializeFirstRoomMusic();
// Add sword attack on tap/click;
// Create a button to kill all enemies in the room
var killAllButton = LK.getAsset('button', {
	anchorX: 0.5,
	anchorY: 0.5
});
killAllButton.x = 100; // Move further to the left
killAllButton.y = 2732 - 350; // Move up
uiContainer.addChild(killAllButton);
// Add event listener for kill all button
killAllButton.down = function (x, y, obj) {
	if (isPopupActive) {
		return;
	}
	// Kill all enemies in the current room
	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(); // Update the room display text
	checkRoomCleared(); // Check if the room is cleared after killing all enemies
	updateRoomDisplay();
	checkRoomCleared();
};
LK.playMusic('room1_music', {
	fade: {
		start: 0,
		end: 1,
		duration: 1000
	}
});
// Create an attack button asset
var attackButton = LK.getAsset('attackIcon', {
	anchorX: 0.5,
	anchorY: 0.5
});
attackButton.x = 2048 - 150; // Position above the weapon switch button
attackButton.y = 2732 - 300; // Adjust position
uiContainer.addChild(attackButton);
// Add event listener for attack button
attackButton.down = function (x, y, obj) {
	if (isPopupActive) {
		return;
	}
	if (hero.weaponType === 1) {
		// Sword attack logic
		hero.isAttacking = true;
		hero.attackCooldown = hero.attackDuration;
		// Swing sword animation
		hero.swordGraphics.rotation = -0.5; // Start swing
		LK.setTimeout(function () {
			hero.swordGraphics.rotation = 0.5; // End swing
		}, hero.attackDuration * 10); // Duration of swing
	} else if (hero.weaponType === 2) {
		// Bow attack logic
		var arrow = new Arrow();
		arrow.x = hero.x;
		arrow.y = hero.y;
		arrow.rotation = hero.rotation; // Match hero's facing direction
		arrows.push(arrow);
		game.addChild(arrow);
	}
};
// Background images for different rooms
// Array of background images for different rooms
var roomBackgroundImages = ['backgroundImage1',
// Replace with actual image asset IDs
'backgroundImage2', 'backgroundImage3', 'backgroundImage4', 'backgroundImage5'];
// Room boundary dimensions
var roomWidth = 2048;
var roomHeight = 2732;
var wallThickness = 400; // Wall thickness around the room
var entranceWidth = 200; // Width of each entrance at middle of edges
// Define spawn points for enemies
var spawnPoints = {
	leftCenter: {
		x: wallThickness,
		y: roomHeight / 2
	},
	rightCenter: {
		x: roomWidth - wallThickness,
		y: roomHeight / 2
	},
	topCenter: {
		x: roomWidth / 2,
		y: wallThickness
	},
	bottomCenter: {
		x: roomWidth / 2,
		y: roomHeight - wallThickness
	}
};
// Coordinates for entrance areas (assuming entrances are centered on each wall)
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
	}
};
// Room class representing individual rooms
// Display room number
var Room = function Room(number) {
	this.number = number;
	this.enemies = [];
	this.isCleared = false;
	this.spawnLimit = this.number === 1 ? 24 : 12 * this.number; // Set spawn limit for room1 to 24, others based on room number
	this.killGoal = this.spawnLimit; // Align kill goal with spawn limit
	this.enemiesSpawned = 0;
	this.enemiesKilled = 0;
	this.enemyCounter = this.spawnLimit;
	// Configure room based on its number for difficulty scaling
	this.init = function () {
		var self = this;
		var spawnInterval = LK.setInterval(function () {
			if (self.enemiesSpawned < self.spawnLimit) {
				self.spawnEnemy();
			} else {
				LK.clearInterval(spawnInterval);
			}
		}, 500); // Spawn every 0.5 seconds
	};
	this.spawnEnemy = function () {
		if (this.enemiesSpawned < this.spawnLimit && !isPopupActive) {
			// Spawn limit set to 50
			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; // Ensure enemy is active
			enemy.health = 10; // Initialize enemy health
			this.enemies.push(enemy);
			game.addChild(enemy); // Ensure enemy is added to the game
			this.enemiesSpawned++;
		}
	};
	this.init();
};
// Initialize the current room only once
var currentRoom = new Room(1);
// Set the initial background when the game starts
var initialBgImage = LK.getAsset('backgroundImage1', {
	anchorX: 0.5,
	anchorY: 0.5
});
initialBgImage.x = 2048 / 2;
initialBgImage.y = 2732 / 2;
game.addChildAt(initialBgImage, 0); // Add at the bottom layer
game.background = initialBgImage; // Store background reference for future transitions
// Create a black bar (statsBar) behind the text elements
var statsBar = LK.getAsset('box', {
	anchorX: 0.0,
	anchorY: 0.0,
	width: 2048,
	height: 100,
	x: 0,
	y: 0
});
game.addChild(statsBar); // Add the statsBar first to ensure it's behind the text
// Room display setup
var roomDisplay = new Text2('Room: ' + currentRoom.number + ' | Enemies Left: ' + (currentRoom.spawnLimit - currentRoom.enemiesKilled), {
	size: 70,
	fill: "#ffffff",
	fontWeight: "bold"
});
roomDisplay.x = 1000; // Move further to the left
roomDisplay.y = 20;
game.addChild(roomDisplay); // Add directly to the game layer
// Update display text
function updateRoomDisplay() {
	var enemiesLeft = currentRoom.spawnLimit - currentRoom.enemiesKilled;
	roomDisplay.setText('Room: ' + currentRoom.number + ' | Enemies Left: ' + Math.max(enemiesLeft, 0));
	healthText.setText('Health: ' + hero.health); // Also update health display
	console.log("Updating room display: Room " + currentRoom.number + ", Enemies Left: " + enemiesLeft); // Debug log
}
var currentRoomMusic;
function transitionToNextRoom() {
	playRoomMusic(currentRoom.number);
	// Clear previous background if it exists
	if (game.background) {
		game.removeChild(game.background);
	}
	// Create a new room with increased difficulty
	currentRoom = new Room(currentRoom.number + 1);
	// Reset the enemy counter to the number of enemies that will be spawned
	currentRoom.enemiesKilled = 0;
	// Update background based on the current room number
	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); // Add at the bottom layer
	game.background = bgImage; // Store background reference for next transition
	currentRoom.enemies.forEach(function (enemy) {
		enemy.active = true; // Reset active state
		enemy.health = 10; // Reset health
		enemy.x = Math.random() * 2048; // Reset position
		enemy.y = Math.random() * 2732;
		game.addChild(enemy); // Ensure enemy is added to the game
	});
	hero.canExitRoom = false; // Reset exit permission for the new room
	currentRoom.isCleared = false; // Reset room cleared status
	updateRoomDisplay(); // Update the room display text
}
// Initialize arrows array to keep track of arrows
var arrows = [];
// Function to check if the room is cleared
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();
		}
		if (currentRoom.number === 1) {
			LK.getSound('room1_music').stop(); // Stop room1_music when room1 is cleared
		} else if (currentRoom.number === 2) {
			LK.getSound('room2_music').stop(); // Stop room2_music when room2 is cleared
		} else if (currentRoom.number === 3) {
			LK.getSound('room3_music').stop(); // Stop room3_music when room3 is cleared
		} else if (currentRoom.number === 4) {
			currentRoomMusic.stop(); // Stop room4_music when room4 is cleared
		} else if (currentRoom.number === 5) {
			currentRoomMusic.stop(); // Stop room5_music when room5 is cleared
		}
		stopRoomMusic(); // Stop the room music when the room is cleared
		currentRoom.isCleared = true;
		console.log("Room Cleared! Entering Room " + (currentRoom.number + 1));
		// Enable room transition by allowing exits
		hero.canExitRoom = true; // Allow hero to exit the room
		updateRoomDisplay(); // Update the room display text
	}
}
function transitionToNewRoom(entrySide) {
	// Reset hero position 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;
	}
	// Clear current enemies and set up the new room
	stopRoomMusic();
	transitionToNextRoom();
	playRoomMusic(currentRoom.number);
	hero.canExitRoom = false; // Disable exit until next room is cleared
}
// Function to transition to the next room
// Initialize skill points
var skillPoints = 3;
// Skill points display
var skillPointsText = new Text2('Skill Points: ' + skillPoints, {
	size: 70,
	fill: "#ffffff",
	fontWeight: "bold"
});
skillPointsText.x = 1024; // Center horizontally
skillPointsText.y = 2632; // Position at the bottom of the screen
game.addChild(skillPointsText);
var hero = gameContainer.addChild(new Hero());
hero.x = 2048 / 2;
hero.y = 2732 / 2;
// Health display
var healthText = new Text2('Health: ' + hero.health, {
	size: 70,
	fill: "#ffffff",
	fontWeight: "bold"
});
healthText.x = 300; // Move further to the left
healthText.y = 20;
game.addChild(healthText); // Add directly to the game layer after statsBar
// Initialize hero movement variables
// Removed moveTarget and moveSpeed to ensure movement is joystick-controlled only
// Add Joystick to the game
var joystick = uiContainer.addChild(new Joystick());
hero.joystick = joystick; // Link joystick to hero for movement control
// Handle joystick events
// Removed game.move event handler to ensure movement is joystick-controlled only
// Removed game.down event handler to ensure movement is joystick-controlled only
// Removed game.up event handler to ensure movement is joystick-controlled only
// Function to handle game updates
game.update = function () {
	// Pause game logic if a popup is active
	if (isPopupActive) {
		return;
	}
	// Continuously update hero position based on joystick input
	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); // Update rotation to face movement direction
		}
	}
	hero.update();
	// Check if hero's health is zero or less
	if (hero.health <= 0) {
		hero.health = 0; // Ensure health does not go below zero
		console.log("Hero has died. Game Over!");
		LK.showGameOver(); // Trigger game over
		return; // Exit update loop
	}
	// Check if hero can exit and is near an exit edge
	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();
		// Check if arrow hits any enemy
		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) {
				// Assuming enemy radius is 60
				currentRoom.enemies[i].health -= arrows[j].damage;
				if (currentRoom.enemies[i].health <= 0) {
					currentRoom.enemiesKilled++;
					currentRoom.enemyCounter--;
					currentRoom.enemies[i].destroy();
					currentRoom.enemies.splice(i, 1);
					console.log("Enemy defeated. Total killed: " + currentRoom.enemiesKilled);
					updateRoomDisplay();
				}
				if (arrows[j]) {
					arrows[j].destroy();
					arrows.splice(j, 1);
				}
				break;
			}
		}
	}
	// Update enemies only if popup is not active
	if (!isPopupActive) {
		for (var i = 0; i < currentRoom.enemies.length; i++) {
			currentRoom.enemies[i].update();
		}
	}
	// Check if the room is cleared after enemies are updated
	checkRoomCleared();
};
// Function to spawn enemies
function spawnEnemy() {
	if (currentRoom.enemiesSpawned < currentRoom.spawnLimit) {}
}
// Removed interval to spawn enemies to prevent continuous spawning
// Set interval to fire enemy bullets
// Removed interval to prevent enemies from shooting
// LK.setInterval(function () {
//     for (var i = 0; i < enemies.length; i++) {
//         fireEnemyBullet(enemies[i]);
//     }
// }, 1000);
// Handle touch/click for movement
// Removed tap-to-move behavior to ensure movement is joystick-controlled only
// Create an invisible button at the bottom-left corner for weapon switching
var switchWeaponZone = LK.getAsset('button', {
	anchorX: 0.5,
	anchorY: 0.5
});
switchWeaponZone.x = 2048 - switchWeaponZone.width / 2; // Center horizontally on the right side
switchWeaponZone.y = 2732 / 2; // Center vertically
uiContainer.addChild(switchWeaponZone);
// Add event listener for weapon switch zone
game.down = function (x, y, obj) {
	// Disable interactions if a popup is active
	if (isPopupActive) {
		return;
	}
	// Check if the click is within the switch weapon zone
	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) {
		// Toggle weapon between sword (1) and bow (2)
		hero.weaponType = hero.weaponType === 1 ? 2 : 1;
		console.log("Switched to weapon type:", hero.weaponType);
		// Show the correct weapon asset
		hero.swordGraphics.visible = hero.weaponType === 1;
		hero.bowGraphics.visible = hero.weaponType === 2;
		return; // Exit the function to avoid triggering an attack
	}
};
// Add sword attack on tap/click

===================================================================
--- original.js
+++ change.js
@@ -537,15 +537,9 @@
 				skillDescriptionText.anchor.set(0.5, 0);
 				popup.addChild(skillDescriptionText);
 				// Test with different skills
 				console.log('Testing displayConfirmationPopup with Data Spike');
-				displayConfirmationPopup({
-					name: 'Data Spike'
-				}, skillNode);
 				console.log('Testing displayConfirmationPopup with Overclock Core');
-				displayConfirmationPopup({
-					name: 'Overclock Core'
-				}, skillNode);
 				// Add Cancel and Spend buttons
 				var cancelButton = new CancelButton();
 				cancelButton.x = popup.width / 3;
 				cancelButton.y = popup.height - 60;