/**** 
* 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);
	// Initialize animation frames for running
	self.animationFrames = [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.currentFrame = 0;
	var enemyGraphics = self.attachAsset('enemy_run1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	enemyGraphics.width = self.animationFrames[self.currentFrame].width;
	enemyGraphics.height = self.animationFrames[self.currentFrame].height;
	self.frameInterval = 10; // Change frame every 10 ticks
	self.frameCounter = 0;
	self.health = 10;
	self.speed = 2;
	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 < 2500) {
				// Activate if within 500 units
				// Keep some distance
				self.x += dx / dist * self.speed;
				self.y += dy / dist * self.speed;
			}
			// Update animation frame only if moving
			if (dx !== 0 || dy !== 0) {
				self.frameCounter++;
				if (self.frameCounter >= self.frameInterval) {
					self.frameCounter = 0;
					self.currentFrame = (self.currentFrame + 1) % self.animationFrames.length;
					enemyGraphics.texture = self.animationFrames[self.currentFrame].texture;
					enemyGraphics.width = self.animationFrames[self.currentFrame].width;
					enemyGraphics.height = self.animationFrames[self.currentFrame].height;
				}
			} else {
				self.frameCounter = 0; // Reset frame counter if not moving
			}
		}
	};
});
// 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 = 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 {
			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) {
			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
****/ 
function stopRoomMusic() {
	if (currentRoomMusic) {
		currentRoomMusic.stop();
	}
}
var currentRoomMusic;
function playRoomMusic(roomNumber) {
	if (currentRoomMusic) {
		currentRoomMusic.stop();
	}
	switch (roomNumber) {
		case 1:
			currentRoomMusic = LK.getSound('room1_music');
			break;
		case 2:
			currentRoomMusic = LK.getSound('room2_music');
			break;
		case 3:
			currentRoomMusic = LK.getSound('room3_music');
			break;
		case 4:
			currentRoomMusic = LK.getSound('room4_music');
			break;
		case 5:
			currentRoomMusic = LK.getSound('room5_music');
			break;
		default:
			currentRoomMusic = null;
	}
	if (currentRoomMusic) {
		currentRoomMusic.play();
	}
}
function initializeFirstRoomMusic() {
	currentRoomMusic = LK.getSound('room1_music');
	currentRoomMusic.play({
		loop: true,
		fade: {
			start: 0,
			end: 1,
			duration: 1000
		}
	});
}
initializeFirstRoomMusic();
// Play background music with fade-in effect
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
game.addChild(attackButton);
// Add event listener for attack button
attackButton.down = function (x, y, obj) {
	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 = Math.min(10 + this.number * 2, 30); // Cap enemy count
	this.killGoal = 50; // Set kill goal to 50 enemies
	this.enemiesSpawned = 0;
	this.enemiesKilled = 0;
	// Configure room based on its number for difficulty scaling
	this.init = function () {
		var self = this;
		var spawnInterval = LK.setInterval(function () {
			if (self.enemiesSpawned < 50) {
				self.spawnEnemy();
			} else {
				LK.clearInterval(spawnInterval);
			}
		}, Math.random() * 1000 + 1000); // Random interval between 1-2 seconds
	};
	this.spawnEnemy = function () {
		if (this.enemiesSpawned < 50) {
			// Spawn limit set to 50
			var spawnKeys = Object.keys(spawnPoints);
			var spawnIndex = Math.floor(Math.random() * spawnKeys.length);
			var spawnPoint = spawnPoints[spawnKeys[spawnIndex]];
			for (var i = 0; i < 2; i++) {
				// Spawn in groups of two
				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
// 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
}
var currentRoomMusic;
function transitionToNextRoom() {
	playRoomMusic(currentRoom.number);
	// Clear previous background if it exists
	if (game.background) {
		game.removeChild(game.background);
	}
	// 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.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 = [];
// 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));
		stopRoomMusic();
		// Play RetroSynth-Wave sound as victory music
		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
	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 = game.addChild(new Hero());
hero.x = 2048 / 2;
hero.y = 2732 / 2;
// 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());
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 () {
	// Continuously update hero position based on joystick input
	if (hero.joystick) {
		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 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 > hero.attackDuration / 2) {
				// 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 - switchWeaponZone.width / 2; // Center horizontally on the right side
switchWeaponZone.y = 2732 / 2; // Center vertically
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
	}
};
// Add sword attack on tap/click

===================================================================
--- original.js
+++ change.js
@@ -72,8 +72,10 @@
 					enemyGraphics.texture = self.animationFrames[self.currentFrame].texture;
 					enemyGraphics.width = self.animationFrames[self.currentFrame].width;
 					enemyGraphics.height = self.animationFrames[self.currentFrame].height;
 				}
+			} else {
+				self.frameCounter = 0; // Reset frame counter if not moving
 			}
 		}
 	};
 });