/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
// Define a class for enemies
var Enemy = Container.expand(function (enemyType) {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset(enemyType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	self.update = function () {
		self.x -= self.speed;
		if (self.x < -50) {
			self.destroy();
		}
	};
});
// Define a class for the life counter
var LifeCounter = Container.expand(function () {
	var self = Container.call(this);
	// Create a simple white line instead of using an asset
	var lineGraphics = LK.getAsset('enemy2', {
		anchorX: 0.0,
		anchorY: 0.0,
		scaleX: 2048,
		scaleY: 10,
		tint: 0xFFFFFF // White color
	});
	self.addChild(lineGraphics);
	self.width = 2048; // Full width
	self.update = function () {
		// Update the width of the line based on Mario's life
		lineGraphics.scale.x = 2048 * Mario.life;
	};
});
// Define a class for the dragon ball lightning effect
var LightningEffect = Container.expand(function () {
	var self = Container.call(this);
	// Set active status flag
	self.isActive = false;
	// Create lightning bolts
	self.bolts = [];
	var colors = [0xFFFF00, 0xFFFF00, 0xFFFF00, 0xFFFF00];
	// Create multiple lightning bolts around Mario
	for (var i = 0; i < 5; i++) {
		var bolt = self.attachAsset('enemy2', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 25 + Math.random() * 10,
			scaleY: 25 + Math.random() * 10
		});
		bolt.tint = colors[Math.floor(Math.random() * colors.length)];
		bolt.alpha = 0; // Start with invisible bolts
		bolt.rotation = Math.random() * Math.PI * 2;
		bolt.distance = 80 + Math.random() * 40;
		bolt.speed = 0.1 + Math.random() * 0.1;
		bolt.originalScale = {
			x: bolt.scale.x,
			y: bolt.scale.y
		};
		self.bolts.push(bolt);
	}
	// Animate the lightning
	self.animate = function () {
		// Stop any existing animations
		for (var i = 0; i < self.bolts.length; i++) {
			tween.stop(self.bolts[i]);
		}
		// Start new animations
		for (var i = 0; i < self.bolts.length; i++) {
			var bolt = self.bolts[i];
			// Randomize the bolt appearance
			bolt.rotation = Math.random() * Math.PI * 2;
			bolt.scale.x = bolt.originalScale.x * (0.8 + Math.random() * 0.4);
			bolt.scale.y = bolt.originalScale.y * (0.8 + Math.random() * 0.4);
			// Animate the bolt with pulse effect
			tween(bolt, {
				alpha: 0.2 + Math.random() * 0.5,
				scaleX: bolt.originalScale.x * (0.7 + Math.random() * 0.6),
				scaleY: bolt.originalScale.y * (0.7 + Math.random() * 0.6)
			}, {
				duration: 300 + Math.random() * 400,
				easing: tween.easeOut,
				onFinish: function () {
					// Create a callback closure to maintain the correct bolt reference
					var currentBolt = bolt;
					return function () {
						// Animate back
						tween(currentBolt, {
							alpha: 0.6 + Math.random() * 0.4,
							scaleX: currentBolt.originalScale.x * (0.9 + Math.random() * 0.3),
							scaleY: currentBolt.originalScale.y * (0.9 + Math.random() * 0.3)
						}, {
							duration: 300 + Math.random() * 400,
							easing: tween.easeIn
						});
					};
				}()
			});
		}
	};
	self.update = function () {
		// Position the lightning bolts around Mario
		for (var i = 0; i < self.bolts.length; i++) {
			var bolt = self.bolts[i];
			var angle = bolt.rotation + self.parent.rotation + bolt.speed * LK.ticks;
			bolt.x = Math.cos(angle) * bolt.distance;
			bolt.y = Math.sin(angle) * bolt.distance;
			// Make bolts invisible when effect is not active
			if (!self.isActive) {
				bolt.alpha = 0;
			}
			// Ensure bolts remain visible when effect is active
			else if (self.isActive && bolt.alpha < 0.7) {
				bolt.alpha = 0.7 + Math.random() * 0.3;
			}
		}
		// Periodically refresh animations only when not in active state
		if (LK.ticks % 30 === 0 && self.isActive) {
			self.animate();
		}
	};
	return self;
});
//<Assets used in the game will automatically appear here>
// Define a class for the player character
var Player = Container.expand(function () {
	var self = Container.call(this);
	var MarioGraphics = self.attachAsset('Mario', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	// Add the lightning effect
	self.lightning = self.addChild(new LightningEffect());
	self.jumpHeight = 40;
	self.isJumping = false;
	self.velocityY = 0;
	self.update = function () {
		if (self.isJumping) {
			self.y += self.velocityY;
			self.velocityY += 0.7; // Decreased gravity effect by 30%
			if (self.y >= 2732 / 2) {
				// Ground level
				self.y = 2732 / 2;
				self.isJumping = false;
				self.velocityY = 0;
			}
		}
		// Update the lightning effect
		if (self.lightning) {
			self.lightning.update();
		}
	};
	self.jump = function () {
		if (!self.isJumping) {
			self.isJumping = true;
			self.velocityY = -self.jumpHeight;
			// Activate lightning effect animation with a more intense glow when jumping, but only if lightning is already active
			if (self.lightning && self.lightning.isActive) {
				// Intensify the lightning effect
				for (var i = 0; i < self.lightning.bolts.length; i++) {
					var bolt = self.lightning.bolts[i];
					tween(bolt, {
						alpha: 0.9,
						scaleX: bolt.originalScale.x * 1.5,
						scaleY: bolt.originalScale.y * 1.5
					}, {
						duration: 300,
						easing: tween.elasticOut
					});
				}
				// Reset to normal after a short time
				LK.setTimeout(function () {
					self.lightning.animate();
				}, 500);
			}
		}
	};
});
// Define a class for power-ups
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var powerGraphics = self.attachAsset('powerup', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 3;
	self.floatOffset = 0;
	self.collected = false;
	// Make power-up glow with tween animation and add shiny flashing effect
	tween(powerGraphics, {
		alpha: 0.7,
		tint: 0xffffff
	}, {
		duration: 1000,
		easing: tween.sinusoidalInOut,
		loop: true,
		yoyo: true
	});
	// Add shiny flashing effect
	function createShinyEffect() {
		// Tween to bright yellow-white (shiny effect)
		tween(powerGraphics, {
			tint: 0xffffff,
			alpha: 1,
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 150,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Tween back to normal gold
				tween(powerGraphics, {
					tint: 0xffd700,
					alpha: 0.8,
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 250,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						// Schedule next flash after a shorter random delay
						LK.setTimeout(createShinyEffect, 300 + Math.random() * 400);
					}
				});
			}
		});
	}
	// Start the shiny effect sequence
	LK.setTimeout(createShinyEffect, 200 + Math.random() * 300);
	self.update = function () {
		// Move power-up from right to left
		self.x -= self.speed;
		// Floating up and down motion
		self.floatOffset += 0.05;
		self.y = self.originalY + Math.sin(self.floatOffset) * 20;
		// Remove if off screen
		if (self.x < -100) {
			self.destroy();
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x87CEEB // Sky blue background
});

/**** 
* Game Code
****/ 
var background = game.addChild(LK.getAsset('background', {
	anchorX: 0,
	anchorY: 0
}));
background.x = 0;
background.y = 0;
// Initialize player
var Mario = game.addChild(new Player());
Mario.x = 2048 / 2;
Mario.y = 2732 / 2;
Mario.life = 1; // Initialize Mario's life to 1 (100%)
// Add life icon to the map
var lifeIcon = game.addChild(LK.getAsset('life', {
	anchorX: 0.5,
	anchorY: 0.5
}));
lifeIcon.x = 2048 - 70;
lifeIcon.y = 50;
// Initialize the life counter and add it to the game
var lifeCounter = game.addChild(new LifeCounter());
lifeCounter.y = 0; // Position it at the top of the screen
// Create life percentage text
var lifePercentText = new Text2('100%', {
	size: 40,
	fill: 0x7FFF00 // Bright neon green to match the life bar
});
// Add the life percentage text to the GUI
LK.gui.topRight.addChild(lifePercentText);
// Position the text
lifePercentText.anchor.set(1, 0); // Right align
lifePercentText.x = -20; // Add right margin
lifePercentText.y = 20; // Add top margin
// Initialize enemies
var enemies = [];
var enemySpawnInterval = 100;
var enemySpawnCounter = 0;
// Initialize power-ups
var powerups = [];
var powerupSpawnInterval = 300;
var powerupSpawnCounter = 0;
// Create a new Text2 object to display the score
var scoreLabelText = new Text2('Defeated opponents: ', {
	size: 40,
	fill: 0xFFFFFF
});
var scoreText = new Text2('0', {
	size: 50,
	fill: 0xFFFFFF
});
// Add the score label and text to the game GUI at the top center of the screen
LK.gui.top.addChild(scoreLabelText);
LK.gui.top.addChild(scoreText);
// Position the label and score text
scoreLabelText.anchor.set(1, 0); // Right align the label
scoreText.anchor.set(0, 0); // Left align the score
scoreLabelText.x = 2048 / 2 - 880; // Position to the left of center, moved 880 units left
scoreLabelText.y = 20; // Add a small top margin
scoreText.x = 2048 / 2 - 840; // Position to the right of center, moved 840 units left
scoreText.y = 10; // Add a small top margin
// Handle game updates
game.update = function () {
	Mario.update();
	// Spawn enemies
	enemySpawnCounter++;
	if (enemySpawnCounter >= enemySpawnInterval) {
		// Define enemy types
		var enemyTypes = ['enemy', 'enemy1', 'enemy2', 'enemy3'];
		// Keep track of the last enemy type to avoid repetition
		if (!game.lastEnemyTypeIndex) {
			game.lastEnemyTypeIndex = -1;
		}
		var i = 0;
		var _spawnEnemy = function spawnEnemy() {
			// Get a new enemy type that is different from the last one
			var availableTypes = [];
			for (var t = 0; t < enemyTypes.length; t++) {
				if (t !== game.lastEnemyTypeIndex) {
					availableTypes.push({
						index: t,
						type: enemyTypes[t]
					});
				}
			}
			// Randomly select from available types
			var selectedType = availableTypes[Math.floor(Math.random() * availableTypes.length)];
			game.lastEnemyTypeIndex = selectedType.index;
			var enemy = new Enemy(selectedType.type);
			enemy.x = 2048 + i * 6 * enemy.width; // Six times the distance between enemies to completely avoid overlap
			enemy.y = 2732 / 2;
			enemies.push(enemy);
			game.addChild(enemy);
			i++;
			if (i < enemyTypes.length) {
				LK.setTimeout(_spawnEnemy, 2000); // Add 2 seconds delay between each enemy spawn
			}
		};
		_spawnEnemy();
		// Randomize the spawn interval for the next enemy
		enemySpawnInterval = Math.floor(Math.random() * 150) + 50;
		enemySpawnCounter = 0;
	}
	// Spawn power-ups
	powerupSpawnCounter++;
	if (powerupSpawnCounter >= powerupSpawnInterval) {
		var powerup = new PowerUp();
		powerup.x = 2048 + 200; // Start a bit off screen
		powerup.y = 2732 / 2 - 200; // Above the players level
		powerup.originalY = powerup.y; // Store original Y for floating animation
		powerup.lastWasIntersecting = false; // For tracking intersection
		powerups.push(powerup);
		game.addChild(powerup);
		// Randomize the spawn interval for the next power-up
		powerupSpawnInterval = Math.floor(Math.random() * 400) + 300;
		powerupSpawnCounter = 0;
	}
	// Update enemies
	for (var j = enemies.length - 1; j >= 0; j--) {
		enemies[j].update();
		if (Mario.intersects(enemies[j])) {
			if (Mario.isJumping || Mario.lightning && Mario.lightning.isActive) {
				// Mario jumped on top of the enemy or has active lightning shield, destroy the enemy
				enemies[j].destroy();
				enemies.splice(j, 1);
				// Add points for defeating enemy 
				if (Mario.lightning && Mario.lightning.isActive) {
					// Add 2 points when defeating with lightning shield
					LK.setScore(LK.getScore() + 2);
					scoreText.setText(LK.getScore());
				} else if (Mario.isJumping) {
					// Add 1 point when jumping on enemy
					LK.setScore(LK.getScore() + 1);
					scoreText.setText(LK.getScore());
				}
			} else {
				Mario.life -= 0.005; // Decrease Mario's life by 0.5%
				if (Mario.life <= 0) {
					LK.effects.flashScreen(0xff0000, 1000);
					LK.showGameOver();
				}
			}
		}
	}
	// Update power-ups
	for (var k = powerups.length - 1; k >= 0; k--) {
		var powerup = powerups[k];
		powerup.update();
		// Check for collision with Mario
		var currentIntersecting = Mario.intersects(powerup);
		if (!powerup.lastWasIntersecting && currentIntersecting) {
			// Power-up collected - apply effect
			powerup.collected = true;
			// Apply power-up effect
			Mario.life = Math.min(1, Mario.life + 0.3); // Restore 30% of life
			// Flash effect when collecting power-up
			LK.effects.flashObject(Mario, 0xFFD700, 500);
			// Enhance lightning effect for 5 seconds
			if (Mario.lightning) {
				// Set effect active flag
				Mario.lightning.isActive = true;
				for (var i = 0; i < Mario.lightning.bolts.length; i++) {
					var bolt = Mario.lightning.bolts[i];
					tween(bolt, {
						alpha: 1,
						scaleX: bolt.originalScale.x * 2,
						scaleY: bolt.originalScale.y * 2
					}, {
						duration: 500,
						easing: tween.elasticOut
					});
				}
				// Reset to normal after 5 seconds (5000ms)
				LK.setTimeout(function () {
					Mario.lightning.isActive = false;
					Mario.lightning.animate();
				}, 5000);
			}
			// Remove the power-up
			powerup.destroy();
			powerups.splice(k, 1);
			// Create a new powerup asset at a random position on the map
			var randomX = Math.random() * 1000 + 500;
			var randomY = Math.random() * 1000 + 500;
			var powerupAsset = game.addChild(LK.getAsset('powerup', {
				anchorX: 0.5,
				anchorY: 0.5
			}));
			powerupAsset.x = randomX;
			powerupAsset.y = randomY;
			// Add a pulsing effect to make it more visible
			tween(powerupAsset, {
				alpha: 0.7,
				scaleX: 1.1,
				scaleY: 1.1
			}, {
				duration: 800,
				easing: tween.sinusoidalInOut,
				loop: true,
				yoyo: true
			});
		}
		// Update tracking state
		if (powerup) {
			powerup.lastWasIntersecting = currentIntersecting;
		}
	}
	// Sort enemies by their x position to ensure they never cover each other in display order
	enemies.sort(function (a, b) {
		return a.x - b.x;
	});
	// Update the life counter
	lifeCounter.update();
	// Update life percentage text
	lifePercentText.setText(Math.round(Mario.life * 100) + '%');
};
// Handle player jump
game.down = function (x, y, obj) {
	Mario.jump();
};

===================================================================
--- original.js
+++ change.js
@@ -437,8 +437,28 @@
 			}
 			// Remove the power-up
 			powerup.destroy();
 			powerups.splice(k, 1);
+			// Create a new powerup asset at a random position on the map
+			var randomX = Math.random() * 1000 + 500;
+			var randomY = Math.random() * 1000 + 500;
+			var powerupAsset = game.addChild(LK.getAsset('powerup', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			}));
+			powerupAsset.x = randomX;
+			powerupAsset.y = randomY;
+			// Add a pulsing effect to make it more visible
+			tween(powerupAsset, {
+				alpha: 0.7,
+				scaleX: 1.1,
+				scaleY: 1.1
+			}, {
+				duration: 800,
+				easing: tween.sinusoidalInOut,
+				loop: true,
+				yoyo: true
+			});
 		}
 		// Update tracking state
 		if (powerup) {
 			powerup.lastWasIntersecting = currentIntersecting;