/**** 
* 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 enemies
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 10;
	self.speed = 5;
	self.update = function () {
		if (!self.active) {
			return;
		} // Check if enemy is active
		// Move enemy toward hero if not too close
		if (typeof hero !== 'undefined') {
			var dx = hero.x - self.x;
			var dy = hero.y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 30 && dist < 500) {
				// Activate if within 500 units
				// Keep some distance
				self.x += dx / dist * self.speed;
				self.y += dy / dist * self.speed;
			}
		}
	};
});
// 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 = 40;
	self.attackDamage = 10;
	self.speed = 10;
	self.joystick = null; // Reference to the Joystick object
	self.update = function () {
		// Update hero position based on joystick input
		if (self.joystick) {
			var direction = self.joystick.getDirection();
			if (direction.x !== 0 || direction.y !== 0) {
				self.x += direction.x * self.speed; // Use hero's speed constant
				self.y += direction.y * self.speed; // Use hero's speed constant
			}
		}
		if (self.attackCooldown > 0) {
			self.attackCooldown--;
		}
		// Ensure sword follows hero's rotation
		self.swordGraphics.rotation = 0;
		// Handle attack animation
		if (self.isAttacking) {
			// Show the sword
			self.swordGraphics.visible = true;
			if (self.attackCooldown <= 25) {
				// Attack animation finished
				self.isAttacking = false;
				// Hide the sword
				self.swordGraphics.visible = false;
			}
		}
	};
});
// 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;
	// Convert global coordinates to local on start drag
	self.startDrag = function (obj) {
		isDragging = true;
		var localPos = self.toLocal(obj.global); // Convert global to local coordinates
		joystickHandle.x = localPos.x;
		joystickHandle.y = localPos.y;
	};
	// Limit joystick handle within max radius during drag
	self.doDrag = function (obj) {
		if (isDragging) {
			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;
		}
	};
	// Reset joystick handle position when dragging stops
	self.endDrag = function () {
		isDragging = false;
		joystickHandle.x = 0; // Reset to center
		joystickHandle.y = 0; // Reset to center
	};
	// Attach event listeners for touch/move actions based on LK engine compatibility
	self.on('pointerdown', function (x, y, obj) {
		self.startDrag(obj);
	});
	self.on('pointermove', function (x, y, obj) {
		self.doDrag(obj);
	});
	self.on('pointerup', function () {
		self.endDrag();
	});
	self.on('pointerupoutside', function () {
		self.endDrag();
	});
	// Provide normalized direction vector based on joystick position
	self.getDirection = function () {
		return {
			x: joystickHandle.x / maxRadius,
			y: joystickHandle.y / maxRadius
		};
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// 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 class representing individual rooms
// Display room number
var Room = function Room(number) {
	this.number = number;
	this.enemies = [];
	this.isCleared = false;
	this.spawnLimit = Math.min(10 + this.number * 2, 30); // Cap enemy count
	this.killGoal = Math.floor(this.spawnLimit * 0.8); // Set kill goal to 80% of spawn limit
	this.enemiesSpawned = 0;
	this.enemiesKilled = 0;
	// Configure room based on its number for difficulty scaling
	this.init = function () {
		for (var i = 0; i < this.spawnLimit; i++) {
			this.spawnEnemy();
		}
	};
	this.spawnEnemy = function () {
		if (this.enemiesSpawned < this.spawnLimit) {
			var enemy = new Enemy();
			enemy.x = Math.random() * 2048;
			enemy.y = Math.random() * 2732;
			enemy.active = true; // Ensure enemy is active
			enemy.health = 10; // Initialize enemy health
			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);
// Room display setup
var roomDisplay = new Text2('Room: ' + currentRoom.number + ' | Enemies Left: ' + (currentRoom.spawnLimit - currentRoom.enemiesKilled), {
	size: 50,
	fill: "#ffffff"
});
roomDisplay.x = 1828; // Position near the top-right corner
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: ' + enemiesLeft);
	healthText.setText('Health: ' + hero.health); // Also update health display
	console.log("Updating room display: Room " + currentRoom.number + ", Enemies Left: " + enemiesLeft); // Debug log
}
// Update room display when transitioning to the next room
function transitionToNextRoom() {
	// Remove existing room entities
	for (var i = currentRoom.enemies.length - 1; i >= 0; i--) {
		if (currentRoom.enemies[i]) {
			currentRoom.enemies[i].destroy();
			currentRoom.enemies.splice(i, 1);
		}
	}
	currentRoom.enemies = [];
	// Create a new room with increased difficulty
	currentRoom = new Room(currentRoom.number + 1);
	// 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.visible = true; // Ensure the background image is visible
	bgImage.x = 2048 / 2;
	bgImage.y = 2732 / 2;
	game.addChildAt(bgImage, 0); // Add background image at the bottom layer
	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 = [];
// Track whether enemies are active
game.enemyActive = true;
// Toggle function for enemy activity
function toggleEnemies() {
	game.enemyActive = !game.enemyActive;
	console.log("Enemies are now " + (game.enemyActive ? "ON" : "OFF"));
	currentRoom.enemies.forEach(function (enemy) {
		enemy.active = game.enemyActive;
	});
}
// Function to check if the room is cleared
function checkRoomCleared() {
	if (currentRoom.enemiesKilled >= currentRoom.killGoal && !currentRoom.isCleared) {
		currentRoom.isCleared = true;
		console.log("Room Cleared! Entering Room " + (currentRoom.number + 1));
		// Play RetroSynth-Wave sound
		var retroSynthWaveSound = LK.getSound('RetroSynth-Wave');
		retroSynthWaveSound.play();
		// 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
	transitionToNextRoom();
	hero.canExitRoom = false; // Disable exit until next room is cleared
}
// Function to transition to the next room
// Initialize game variables
var hero = game.addChild(new Hero());
hero.x = 2048 / 2;
hero.y = 2732 - 200;
// Health display
var healthText = new Text2('Health: ' + hero.health, {
	size: 50,
	fill: "#ffffff"
});
healthText.x = 1024;
healthText.y = 20;
game.addChild(healthText); // Add directly to the game layer
// Initialize hero movement variables
// Removed moveTarget and moveSpeed to ensure movement is joystick-controlled only
// Add Joystick to the game
var joystick = game.addChild(new Joystick());
// 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 () {
	// Update hero
	hero.update();
	// 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.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 they are active
	if (game.enemyActive) {
		for (var i = currentRoom.enemies.length - 1; i >= 0; i--) {
			if (currentRoom.enemies[i].active) {
				currentRoom.enemies[i].update();
			}
			// Move enemy toward hero if not too close
			var dx = hero.x - currentRoom.enemies[i].x;
			var dy = hero.y - currentRoom.enemies[i].y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 30 && dist < 500) {
				// Activate if within 500 units
				// Keep some distance
				currentRoom.enemies[i].x += dx / dist * currentRoom.enemies[i].speed;
				currentRoom.enemies[i].y += dy / dist * currentRoom.enemies[i].speed;
			}
			// Check if enemy is close enough to damage the hero
			if (dist < 50) {
				// Assuming proximity threshold is 50
				hero.health -= 1; // Reduce hero's health
				healthText.setText('Health: ' + hero.health); // Update health display
				// Check if hero's health reaches zero
				if (hero.health <= 0) {
					LK.showGameOver(); // Trigger game over
				}
			}
			// Check if enemy is hit by sword
			if (hero.isAttacking && hero.attackCooldown > 25) {
				// Only check during attack frames
				var hitDx = currentRoom.enemies[i].x - (hero.x + Math.cos(hero.rotation) * (hero.attackRange / 2));
				var hitDy = currentRoom.enemies[i].y - (hero.y + Math.sin(hero.rotation) * (hero.attackRange / 2));
				var hitDist = Math.sqrt(hitDx * hitDx + hitDy * hitDy);
				if (hitDist < hero.attackRange / 2 + 60) {
					// Assuming enemy radius is 60
					currentRoom.enemies[i].health -= hero.attackDamage;
					if (currentRoom.enemies[i].health <= 0) {
						currentRoom.enemiesKilled++;
						currentRoom.enemies[i].destroy();
						currentRoom.enemies.splice(i, 1); // Remove enemy from the array
						updateRoomDisplay();
					}
				}
			}
			if (currentRoom.enemies[i] && currentRoom.enemies[i].y > 2732) {
				currentRoom.enemies[i].destroy();
				currentRoom.enemies.splice(i, 1);
			}
		}
	}
	// Check if the room is cleared after enemies are updated
	checkRoomCleared();
};
// Function to spawn enemies
function spawnEnemy() {
	if (currentRoom.enemiesSpawned < currentRoom.spawnLimit) {
		var enemy = new Enemy();
		enemy.x = Math.random() * 2048;
		enemy.y = 0;
		currentRoom.enemies.push(enemy);
		game.addChild(enemy);
		currentRoom.enemiesSpawned++;
	}
}
// 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 - 150; // Move to the right side of the screen
switchWeaponZone.y = 2732 - 200; // Move up a little
game.addChild(switchWeaponZone);
// Add event listener for weapon switch zone
game.down = function (x, y, obj) {
	// 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
	}
	// If the click is not on any button, perform an attack
	if (hero.attackCooldown <= 0) {
		hero.isAttacking = true;
		hero.attackCooldown = 30; // Set cooldown frames
		// Determine attack direction based on tap position
		var dx = x - hero.x;
		var dy = y - hero.y;
		hero.rotation = Math.atan2(dy, dx);
		if (hero.weaponType === 1) {
			// Sword attack logic
			console.log("Sword attack initiated");
			// Create attack hitbox in front of hero
			var hitbox = {
				x: hero.x + Math.cos(hero.rotation) * (hero.attackRange / 2),
				y: hero.y + Math.sin(hero.rotation) * (hero.attackRange / 2),
				radius: hero.attackRange / 2
			};
			// TODO: Check for enemies in hitbox and damage them
		} else if (hero.weaponType === 2) {
			// Bow attack logic
			console.log("Bow attack initiated");
			// Create a new arrow
			var arrow = new Arrow();
			arrow.x = hero.x;
			arrow.y = hero.y;
			arrow.rotation = hero.rotation;
			game.addChild(arrow);
			// Add arrow to update list
			arrows.push(arrow);
		}
	}
};
// Add sword attack on tap/click

===================================================================
--- original.js
+++ change.js