/**** 
* Classes
****/ 
// New Creature class representing a different enemy
var Creature = Container.expand(function () {
	var self = Container.call(this);
	var creatureGraphics = self.attachAsset('creature', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.update = function () {
		// Move the creature down the screen
		self.y += self.speed;
		// Add a simple animation to the creature
		// Removed rotation animation for performance optimization
	};
});
// 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.speed = 10;
	self.update = function () {
		// Move the enemy down the screen
		self.y += self.speed;
		// Add a simple animation to the enemy
		// Removed rotation animation for performance optimization
	};
});
// Maze class representing the maze box
var Maze = Container.expand(function () {
	var self = Container.call(this);
	var mazeGraphics = self.attachAsset('maze', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		// Update logic for the maze
	};
});
// Monster class representing a monster that spawns above the player
var Monster = Container.expand(function () {
	var self = Container.call(this);
	var monsterGraphics = self.attachAsset('creature', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	self.update = function () {
		// Move the monster down the screen
		self.y += self.speed;
	};
});
//<Assets used in the game will automatically appear here>
//<Write imports for supported plugins here>
// Ninja class representing the player character
var Ninja = Container.expand(function () {
	var self = Container.call(this);
	var ninjaGraphics = self.attachAsset('ninja', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 10;
	self.update = function () {
		// Update logic for the ninja
		// Move left if the ninja is not at the left edge of the screen
		if (self.x > 0) {
			self.x -= self.speed;
			// Removed rotation animation for performance optimization
		}
		// Move right if the ninja is not at the right edge of the screen
		if (self.x < 2048) {
			self.x += self.speed;
		}
		// Reset rotation when the ninja is not moving
		if (self.speed == 0) {}
	};
	self.dodge = function () {
		// Logic for dodging obstacles
	};
	self.slice = function () {
		// Logic for slicing through enemies
	};
});
// Obstacle class representing the obstacles
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obstacleGraphics = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		// Update logic for the obstacle
	};
});
// PowerUp class representing a power-up item
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var powerUpGraphics = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	self.update = function () {
		// Move the power-up down the screen
		self.y += self.speed;
	};
});

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

/**** 
* Game Code
****/ 
// Set interval to spawn power-ups
var powerUpSpawnInterval = 10000;
var powerUpSpawnTimer = LK.setInterval(spawnPowerUp, powerUpSpawnInterval);
// Function to spawn power-ups
function spawnPowerUp() {
	var powerUp = new PowerUp();
	powerUp.x = Math.random() * 2048;
	powerUp.y = -100;
	powerUps.push(powerUp);
	game.addChild(powerUp);
}
// Initialize array to keep track of power-ups
var powerUps = [];
// Set interval to spawn monsters
var monsterSpawnInterval = 3000;
var monsterSpawnTimer = LK.setInterval(spawnMonster, monsterSpawnInterval);
// Function to spawn monsters
function spawnMonster() {
	var monster = new Monster();
	monster.x = ninja.x; // Spawn above the ninja
	monster.y = -100;
	monsters.push(monster);
	game.addChild(monster);
}
// Set interval to spawn creatures
var creatureSpawnInterval = 2000;
var creatureSpawnTimer = LK.setInterval(spawnCreature, creatureSpawnInterval);
// Function to spawn creatures
function spawnCreature() {
	var creature = new Creature();
	creature.x = Math.random() * 2048;
	creature.y = -100;
	creatures.push(creature);
	game.addChild(creature);
}
// Initialize arrays to keep track of enemies, obstacles, creatures, and monsters
var enemies = [];
var obstacles = [];
var creatures = [];
var monsters = [];
// Create the ninja character and add to the game
var ninja = game.addChild(new Ninja());
ninja.x = 2048 / 2;
ninja.y = 2732 - 200;
// Create the maze and add to the game
var maze = game.addChild(new Maze());
maze.x = ninja.x;
maze.y = -100;
// Function to handle game updates
game.update = function () {
	// Update ninja
	ninja.update();
	// Update enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		if (enemy.y <= 2732) {
			enemy.update();
		} else {
			enemy.destroy();
			enemies.splice(i, 1);
		}
	}
	// Update creatures
	for (var c = creatures.length - 1; c >= 0; c--) {
		var creature = creatures[c];
		if (creature.y <= 2732) {
			creature.update();
		} else {
			creature.destroy();
			creatures.splice(c, 1);
		}
	}
	// Update monsters
	for (var m = monsters.length - 1; m >= 0; m--) {
		var monster = monsters[m];
		if (monster.y <= 2732) {
			monster.update();
		} else {
			monster.destroy();
			monsters.splice(m, 1);
		}
	}
	// Update obstacles
	for (var j = obstacles.length - 1; j >= 0; j--) {
		var obstacle = obstacles[j];
		if (obstacle.y <= 2732) {
			obstacle.update();
		} else {
			obstacle.destroy();
			obstacles.splice(j, 1);
		}
	}
	// Update the score text
	scoreText.setText(LK.getScore());
	// Check for collisions between ninja and enemies
	for (var k = 0; k < enemies.length; k++) {
		if (ninja.intersects(enemies[k])) {
			// Handle collision with enemy
			// Removed screen flash effect for performance optimization
			// Display the score when the game is over
			var score = LK.getScore();
			scoreText.setText("Score: " + score);
			LK.showGameOver();
		}
	}
	// Check for collisions between ninja and creatures
	for (var m = 0; m < creatures.length; m++) {
		if (ninja.intersects(creatures[m])) {
			// Handle collision with creature
			// Removed screen flash effect for performance optimization
			// Display the score when the game is over
			var score = LK.getScore();
			scoreText.setText("Score: " + score);
			LK.showGameOver();
		}
	}
	// Check for collisions between ninja and power-ups
	for (var p = 0; p < powerUps.length; p++) {
		if (ninja.intersects(powerUps[p])) {
			// Handle collision with power-up
			ninja.speed += 5; // Increase ninja's speed temporarily
			powerUps[p].destroy();
			powerUps.splice(p, 1);
		}
	}
	// Check for collisions between ninja and obstacles
	for (var l = 0; l < obstacles.length; l++) {
		if (ninja.intersects(obstacles[l])) {
			// Handle collision with obstacle
			ninja.dodge();
		}
	}
};
// Create a Text2 object to display the score
var scoreText = new Text2('0', {
	size: 150,
	fill: 0xFFFFFF
});
// Add the score text to the GUI overlay at the top-center of the screen
LK.gui.top.addChild(scoreText);
// Function to spawn enemies
function spawnEnemy() {
	var enemy = new Enemy();
	enemy.x = Math.random() * 2048;
	enemy.y = -100;
	enemies.push(enemy);
	game.addChild(enemy);
}
// Function to increase score every second
function increaseScore() {
	LK.setScore(LK.getScore() + 1);
	if (LK.ticks % 60 === 0) {
		// Update score text every second
		scoreText.setText(LK.getScore());
	}
}
var scoreIncreaseTimer = LK.setInterval(increaseScore, 1000);
// Function to spawn obstacles
function spawnObstacle() {
	var obstacle = new Obstacle();
	obstacle.x = Math.random() * 2048;
	obstacle.y = -100;
	obstacles.push(obstacle);
	game.addChild(obstacle);
}
// Set intervals to spawn enemies and obstacles
var enemySpawnInterval = 1000;
var obstacleSpawnInterval = 3000;
var enemySpawnTimer = LK.setInterval(spawnEnemy, enemySpawnInterval);
var obstacleSpawnTimer = LK.setInterval(spawnObstacle, obstacleSpawnInterval);
// Increase difficulty every 5 seconds
var difficultyIncreaseTimer = LK.setInterval(function () {
	enemySpawnInterval = Math.max(500, enemySpawnInterval - 100);
	obstacleSpawnInterval = Math.max(1000, obstacleSpawnInterval - 200);
	LK.clearInterval(enemySpawnTimer);
	LK.clearInterval(obstacleSpawnTimer);
	enemySpawnTimer = LK.setInterval(spawnEnemy, enemySpawnInterval);
	obstacleSpawnTimer = LK.setInterval(spawnObstacle, obstacleSpawnInterval);
}, 5000);
// Handle touch events for ninja actions
game.down = function (x, y, obj) {
	// Move the ninja to the touched position
	ninja.x = x;
};
game.up = function (x, y, obj) {
	// Stop the ninja's movement when the touch is released
	ninja.speed = 0;
};

===================================================================
--- original.js
+++ change.js
@@ -96,8 +96,21 @@
 	self.update = function () {
 		// Update logic for the obstacle
 	};
 });
+// PowerUp class representing a power-up item
+var PowerUp = Container.expand(function () {
+	var self = Container.call(this);
+	var powerUpGraphics = self.attachAsset('obstacle', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.speed = 5;
+	self.update = function () {
+		// Move the power-up down the screen
+		self.y += self.speed;
+	};
+});
 
 /**** 
 * Initialize Game
 ****/ 
@@ -107,8 +120,21 @@
 
 /**** 
 * Game Code
 ****/ 
+// Set interval to spawn power-ups
+var powerUpSpawnInterval = 10000;
+var powerUpSpawnTimer = LK.setInterval(spawnPowerUp, powerUpSpawnInterval);
+// Function to spawn power-ups
+function spawnPowerUp() {
+	var powerUp = new PowerUp();
+	powerUp.x = Math.random() * 2048;
+	powerUp.y = -100;
+	powerUps.push(powerUp);
+	game.addChild(powerUp);
+}
+// Initialize array to keep track of power-ups
+var powerUps = [];
 // Set interval to spawn monsters
 var monsterSpawnInterval = 3000;
 var monsterSpawnTimer = LK.setInterval(spawnMonster, monsterSpawnInterval);
 // Function to spawn monsters
@@ -210,8 +236,17 @@
 			scoreText.setText("Score: " + score);
 			LK.showGameOver();
 		}
 	}
+	// Check for collisions between ninja and power-ups
+	for (var p = 0; p < powerUps.length; p++) {
+		if (ninja.intersects(powerUps[p])) {
+			// Handle collision with power-up
+			ninja.speed += 5; // Increase ninja's speed temporarily
+			powerUps[p].destroy();
+			powerUps.splice(p, 1);
+		}
+	}
 	// Check for collisions between ninja and obstacles
 	for (var l = 0; l < obstacles.length; l++) {
 		if (ninja.intersects(obstacles[l])) {
 			// Handle collision with obstacle