/**** 
* 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();
		}
	};
});
// 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;
});

/**** 
* 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"
	});
	titleText.x = position.x;
	titleText.y = position.y + 100;
	titleText.anchor.set(0.5, 0);
	// Attach skill tree asset to each title
	var skillTreeAsset = LK.getAsset(skillTree.title.toLowerCase().replace(/\s+/g, ''), {
		anchorX: 0.5,
		anchorY: 0.5
	});
	skillTreeAsset.x = position.x;
	skillTreeAsset.y = position.y;
	skillTreePopup.addChild(skillTreeAsset);
	// Add click event to change the skill tree icon and log the skill tree name
	skillTreeAsset.down = function () {
		console.log(skillTree.title + " selected");
		// Change the skill tree icon to indicate selection
		skillTreeAsset.tint = 0xffcc00; // Example: change color to indicate selection
		// Close the popup and resume game logic
		menuContainer.removeChild(skillTreePopup);
		isPopupActive = false;
	};
	// 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);
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 = 150; // Position on the left side
killAllButton.y = 2732 - 300; // Adjust position
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--) {
		currentRoom.enemies[i].destroy();
		currentRoom.enemies.splice(i, 1);
		currentRoom.enemiesKilled++;
		updateRoomDisplay(); // Update the room display text
	}
	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 game variables
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
@@ -348,9 +348,9 @@
 	skillTreeAsset.x = position.x;
 	skillTreeAsset.y = position.y;
 	skillTreePopup.addChild(skillTreeAsset);
 	// Add click event to change the skill tree icon and log the skill tree name
-	titleText.down = function () {
+	skillTreeAsset.down = function () {
 		console.log(skillTree.title + " selected");
 		// Change the skill tree icon to indicate selection
 		skillTreeAsset.tint = 0xffcc00; // Example: change color to indicate selection
 		// Close the popup and resume game logic