/**** 
* 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);
		// If the game hasn't started yet, start it, else resume it
		if (!gameStarted) {
			// Starting the game for the first time
			gameStarted = true;
			initializeGame();
			LK.playMusic('room1_music', {
				loop: true
			});
		} else {
			// Resuming the game if it was paused
			gamePaused = false;
			isPopupActive = false;
			isDataSpikePopupActive = false;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var openSkillTreeButton = LK.getAsset('attackIcon', {
	anchorX: 0.5,
	anchorY: 0.5
});
// Place it somewhere on the screen, for example top-left corner
openSkillTreeButton.x = 200;
openSkillTreeButton.y = 200;
uiContainer.addChild(openSkillTreeButton);
openSkillTreeButton.down = function (x, y, obj) {
	if (!isPopupActive && gameStarted) {
		// Open the skillTreePopup again
		menuContainer.addChild(skillTreePopup);
		isPopupActive = true;
		gamePaused = true; // Pause the game when skill tree is opened during gameplay
	}
};
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; // For displaying skill points
var gamePaused = false; // Track if the game is paused
var gameStarted = false; // Track if the game has started or not
// Define refreshTreePointsText globally so it's accessible everywhere
function refreshTreePointsText() {
	if (skillTreePointsText) {
		skillTreePointsText.setText('Skill Points: ' + heroSkillPoints);
	}
}
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();
game.addChild(uiContainer);
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 || gamePaused) {
		// If paused or popup active, do not update hero or enemies
		return;
	}
	if (hero.joystick && !isPopupActive && !gamePaused) {
		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);
	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);
		var backButton = new BackButton();
		newPopup.addChild(backButton);
		var 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: 'neural_hijack_icon',
			x: 2048 / 4,
			y: 2 * 2732 / 6,
			name: 'Neural Hijack'
		}, {
			id: 'dodge_matrix_icon',
			x: 2048 / 2,
			y: 2 * 2732 / 6,
			name: 'Dodge Matrix'
		}, {
			id: 'brown_node_icon',
			x: 3 * 2048 / 4,
			y: 2 * 2732 / 6,
			name: 'Power Surge'
		}, {
			id: 'ultimate_skill_icon',
			x: 2048 / 2,
			y: 3 * 2732 / 6,
			name: 'Ultimate Skill'
		}];
		skillNodes.forEach(function (node) {
			var skillNode = LK.getAsset(node.id, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			skillNode.x = node.x;
			skillNode.y = node.y;
			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 === 'Ultimate Skill') {
					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);
	} 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);
	}
	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 skillTreePointsText at the bottom of the newPopup
	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);
	refreshTreePointsText(); // Update skill points display
	menuContainer.addChild(newPopup);
}

===================================================================
--- original.js
+++ change.js
@@ -278,22 +278,15 @@
 
 /**** 
 * Game Code
 ****/ 
-// Containers are defined once at the start of the Game Code section
-var uiContainer = new Container();
-var menuContainer = new Container();
-game.addChild(uiContainer);
-game.addChild(menuContainer);
-// Ensure uiContainer is defined above
 var openSkillTreeButton = LK.getAsset('attackIcon', {
 	anchorX: 0.5,
 	anchorY: 0.5
 });
-// Place it somewhere on the screen
+// Place it somewhere on the screen, for example top-left corner
 openSkillTreeButton.x = 200;
 openSkillTreeButton.y = 200;
-// Now uiContainer is defined, so we can add the button
 uiContainer.addChild(openSkillTreeButton);
 openSkillTreeButton.down = function (x, y, obj) {
 	if (!isPopupActive && gameStarted) {
 		// Open the skillTreePopup again
@@ -372,9 +365,15 @@
 		x: roomWidth - wallThickness,
 		y: roomHeight - wallThickness
 	}
 };
-// Containers are defined once at the start of the Game Code section
+var gameContainer = new Container();
+var uiContainer = new Container();
+game.addChild(uiContainer);
+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;