/**** 
* 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.enemyType = enemyType;
	// Apply spinning animation to 'ls' enemy type
	if (enemyType === 'ls') {
		// Start spinning animation in left (counter-clockwise) direction
		tween(enemyGraphics, {
			rotation: Math.PI * 2 * -1 // Negative for left/counter-clockwise direction
		}, {
			duration: 2000,
			// 2 seconds for a full rotation
			easing: tween.linear,
			repeat: Infinity,
			// Use Infinity instead of loop: true for continuous spinning
			loop: true // Continuous spinning
		});
	}
	self.update = function () {
		// Special behavior for ls asset - bounce down from top right
		if (self.enemyType === 'ls') {
			// Add vertical movement properties first time
			if (self.verticalSpeed === undefined) {
				self.verticalSpeed = 3; // Initial downward speed
				self.gravity = 0.1; // Gravity effect
				self.bounceStrength = 2; // How strong the bounce is
				// Start from top-right corner
				self.y = 100; // Near top
				self.x = 2048 + 100; // Off right edge
			}
			// Track if this asset is in the spinning out state
			if (self.spinningOut) {
				// Move toward right top corner
				var targetX = 2048 + 200;
				var targetY = -200;
				// Calculate direction vector
				var dirX = targetX - self.x;
				var dirY = targetY - self.y;
				// Normalize and apply speed
				var length = Math.sqrt(dirX * dirX + dirY * dirY);
				if (length > 0) {
					dirX = dirX / length * (self.spinSpeed || 15);
					dirY = dirY / length * (self.spinSpeed || 15);
				}
				// Move toward target
				self.x += dirX;
				self.y += dirY;
				// Increase rotation speed
				self.children[0].rotation += 0.2;
			} else {
				// Normal behavior when not spinning out
				// Apply gravity to vertical speed
				self.verticalSpeed += self.gravity;
				self.y += self.verticalSpeed;
				// Bounce when hitting bottom at 3/4 of the screen height instead of center
				if (self.y > 2732 * 0.75) {
					// Bounce at 3/4 screen height
					self.y = 2732 * 0.75;
					self.verticalSpeed = -self.verticalSpeed * (self.bounceStrength * 0.3); // Even lower bounce power
					// Reduce bounce strength much more quickly
					self.bounceStrength *= 0.5;
				}
				// Horizontal movement
				self.x -= self.speed;
			}
		} else if (self.enemyType === 'enemy3') {
			// Special behavior for enemy3 - attack from right bottom corner
			if (self.initialPosition === undefined) {
				// Set initial position at right bottom corner
				self.x = 2048 + 100; // Off right edge
				self.y = 2732 - 550; // Bottom of screen with small margin, moved up by 450 units
				self.initialPosition = true;
			}
			// Move diagonally up-left (towards Mario)
			self.x -= self.speed * 1.2;
			self.y -= self.speed * 0.6;
		} else {
			// Original behavior for other enemy types
			self.x -= self.speed;
		}
		// Destroy when off screen
		if (self.x < -50) {
			self.destroy();
		}
	};
	return self; // Return self to make the class inheritable
});
// Define a class for displaying the God Mode text
var GodModeText = Container.expand(function () {
	var self = Container.call(this);
	// Create the text
	var godModeText = new Text2('GOD MODE', {
		size: 80,
		fill: 0xFF8C00 // Orange color
	});
	godModeText.anchor.set(0.5, 0.5);
	self.addChild(godModeText);
	// Initialize with invisible state
	godModeText.alpha = 0;
	// Create timer text
	var timerText = new Text2('', {
		size: 60,
		fill: 0xFF8C00 // Orange color for timer
	});
	timerText.anchor.set(0.5, 0.5);
	timerText.y = 80; // Position below the GOD MODE text
	self.addChild(timerText);
	// Initialize timer value
	self.timerValue = 5; // 5 seconds duration
	self.timerInterval = null;
	// Method to show the animation
	self.showAnimation = function () {
		// Play god mode sound
		LK.getSound('godmode').play();
		// Stop any existing animations
		tween.stop(godModeText);
		// Reset and start the timer
		self.timerValue = 5;
		timerText.setText(self.timerValue);
		timerText.alpha = 1;
		// Clear any existing timer
		if (self.timerInterval) {
			LK.clearInterval(self.timerInterval);
		}
		// Start countdown timer
		self.timerInterval = LK.setInterval(function () {
			self.timerValue -= 1;
			timerText.setText(self.timerValue);
			if (self.timerValue < 0) {
				LK.clearInterval(self.timerInterval);
				self.timerInterval = null;
			}
		}, 1000);
		// Animate in
		tween(godModeText, {
			alpha: 1,
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 300,
			easing: tween.elasticOut,
			onFinish: function onFinish() {
				// Pulse animation while visible
				tween(godModeText, {
					scaleX: 1.1,
					scaleY: 1.1
				}, {
					duration: 800,
					easing: tween.sinusoidalInOut,
					yoyo: true,
					loop: true
				});
				// Hide after 3 seconds
				LK.setTimeout(function () {
					// Stop the pulse animation
					tween.stop(godModeText);
					// Stop and hide the timer
					if (self.timerInterval) {
						LK.clearInterval(self.timerInterval);
						self.timerInterval = null;
					}
					tween(timerText, {
						alpha: 0
					}, {
						duration: 300,
						easing: tween.easeIn
					});
					// Animate out
					tween(godModeText, {
						alpha: 0,
						scaleX: 0.8,
						scaleY: 0.8
					}, {
						duration: 500,
						easing: tween.easeIn
					});
				}, 3000);
			}
		});
	};
	return self;
});
// 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;
			// Play jump sound
			LK.getSound('jump').play();
			// 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;
// Play background music
LK.playMusic('music1', {
	loop: true
});
// Initialize player
var Mario = game.addChild(new Player());
Mario.x = 2048 / 2 - 200; // Position Mario 200 units to the left of center
Mario.y = 2732 / 2;
Mario.life = 1; // Initialize Mario's life to 1 (100%)
// 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 GodModeText instance
var godModeText = game.addChild(new GodModeText());
godModeText.x = 2048 / 2; // Center horizontally
godModeText.y = 2732 / 2 - 700; // Position above the center (moved up by 300 units)
// 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++;
	// Define maximum number of active enemies allowed at once
	var maxEnemies = 5;
	if (enemySpawnCounter >= enemySpawnInterval && enemies.length < maxEnemies) {
		// Define enemy types
		var enemyTypes = ['enemy', 'enemy1', 'enemy2', 'enemy3', 'jjb', 'ls'];
		// Keep track of the last enemy type to avoid repetition
		if (!game.lastEnemyTypeIndex) {
			game.lastEnemyTypeIndex = -1;
		}
		var i = 0;
		var _spawnEnemy = function spawnEnemy() {
			// Check if we reached the maximum number of enemies
			if (enemies.length >= maxEnemies) {
				return; // Don't spawn more enemies if we reached the limit
			}
			// Get a new enemy type that is different from the last one
			var availableTypes = [];
			for (var t = 0; t < enemyTypes.length; t++) {
				// Skip enemy2 type which is too small to be visible (4x4)
				if (t !== game.lastEnemyTypeIndex && enemyTypes[t] !== 'enemy2') {
					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 * 8 * enemy.width; // Eight times the distance between enemies to completely avoid overlap
			enemy.y = 2732 / 2;
			enemies.push(enemy);
			game.addChild(enemy);
			i++;
			if (i < enemyTypes.length && enemies.length < maxEnemies) {
				LK.setTimeout(_spawnEnemy, 3500); // Increase delay to 3.5 seconds 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])) {
			// Special handling for 'ls' asset during God mode
			if (enemies[j].enemyType === 'ls' && Mario.lightning && Mario.lightning.isActive) {
				// Start the spinning out animation if not already spinning
				if (!enemies[j].spinningOut) {
					enemies[j].spinningOut = true;
					enemies[j].spinSpeed = 15; // Speed at which it flies out
					// Play dog sound when ls starts spinning out
					LK.getSound('dog').play();
					// Increase rotation animation
					tween(enemies[j].children[0], {
						rotation: Math.PI * 10
					}, {
						duration: 2000,
						easing: tween.linear
					});
					// Add points for special effect
					LK.setScore(LK.getScore() + 3); // Bonus points for this special effect
					scoreText.setText(LK.getScore());
				}
				// Don't remove from array yet - let it spin out of screen
			} else 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);
			// Show God mode text animation for 3 seconds
			godModeText.showAnimation();
			// Play god mode sound
			LK.getSound('godmode').play();
			// 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
					});
				}
				// Update timer with the godmode duration (5 seconds)
				godModeText.timerValue = 5;
				// 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);
		}
		// 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();
};