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

/**** 
* Classes
****/ 
var AttackButton = Container.expand(function (attackData) {
	var self = Container.call(this);
	self.attackData = attackData;
	// Button background
	self.bg = self.attachAsset('attackButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Attack name
	self.nameText = new Text2(attackData.name, {
		size: 36,
		fill: 0xFFFFFF
	});
	self.nameText.anchor.set(0.5, 0);
	self.nameText.y = -30;
	self.addChild(self.nameText);
	// Attack stats
	self.statsText = new Text2("DMG: " + attackData.damage + " | EN: " + attackData.energy, {
		size: 26,
		fill: 0xFFFFFF
	});
	self.statsText.anchor.set(0.5, 1);
	self.statsText.y = 30;
	self.addChild(self.statsText);
	// Interactive
	self.bg.interactive = true;
	// Event handlers
	self.down = function (x, y, obj) {
		self.bg.alpha = 0.7;
	};
	self.up = function (x, y, obj) {
		self.bg.alpha = 1;
		if (self.onAttack) {
			self.onAttack(self.attackData);
		}
	};
	self.disable = function () {
		self.bg.alpha = 0.5;
		self.bg.interactive = false;
	};
	self.enable = function () {
		self.bg.alpha = 1;
		self.bg.interactive = true;
	};
	return self;
});
var BloodSplatter = Container.expand(function () {
	var self = Container.call(this);
	// Attach the blood splatter asset
	var effectGraphics = self.attachAsset('bloodSplatterEffect', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.alpha = 1;
	// Randomize scale and rotation for a bit of variety
	var randomScale = 0.5 + Math.random() * 0.7; // Scale between 0.5 and 1.2
	self.scale.set(randomScale);
	self.rotation = Math.random() * Math.PI * 2; // Random rotation
	var lifeFrames = 25; // Effect duration in frames (थोड़ा 0.5 सेकंड से कम 60FPS पर)
	// This update function will be called by the LK engine automatically
	// as long as the BloodSplatter instance is added to a displayed container (e.g., game)
	self.update = function () {
		lifeFrames--;
		// Fade out the effect
		self.alpha = Math.max(0, lifeFrames / 25);
		if (lifeFrames <= 0) {
			// Remove from parent container and destroy when life is up
			if (self.parent) {
				self.parent.removeChild(self);
			}
			self.destroy(); // Clean up the PIXI object
		}
	};
	return self;
});
var Fighter = Container.expand(function (isPlayer, maxHealth, maxEnergy) {
	var self = Container.call(this);
	self.isPlayer = isPlayer || false;
	self.maxHealth = maxHealth || 100;
	self.maxEnergy = maxEnergy || 100;
	self.health = self.maxHealth;
	self.energy = self.maxEnergy;
	self.name = isPlayer ? "Player" : "Enemy";
	// Sprite and visual elements
	self.sprite = self.attachAsset(isPlayer ? 'player' : 'enemy' + (currentLevel || 1), {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Health bar container
	self.healthBarContainer = new Container();
	self.addChild(self.healthBarContainer);
	// Health bar background
	self.healthBarBg = LK.getAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5,
		alpha: 0.3
	});
	self.healthBarContainer.addChild(self.healthBarBg);
	// Health bar foreground
	self.healthBarFg = LK.getAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	self.healthBarContainer.addChild(self.healthBarFg);
	// Energy bar container
	self.energyBarContainer = new Container();
	self.addChild(self.energyBarContainer);
	// Energy bar background
	self.energyBarBg = LK.getAsset('energyBar', {
		anchorX: 0,
		anchorY: 0.5,
		alpha: 0.3
	});
	self.energyBarContainer.addChild(self.energyBarBg);
	// Energy bar foreground
	self.energyBarFg = LK.getAsset('energyBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	self.energyBarContainer.addChild(self.energyBarFg);
	// Name label
	self.nameLabel = new Text2(self.name, {
		size: 36,
		fill: 0xFFFFFF
	});
	self.nameLabel.anchor.set(0.5, 0.5);
	self.addChild(self.nameLabel);
	// Position elements
	if (isPlayer) {
		// Position at top-left
		self.healthBarContainer.x = -self.healthBarBg.width / 2;
		self.healthBarContainer.y = -self.sprite.height / 2 - 600;
		self.energyBarContainer.x = -self.energyBarBg.width / 2;
		self.energyBarContainer.y = -self.sprite.height / 2 - 550;
		self.nameLabel.x = 0;
		self.nameLabel.y = -self.sprite.height / 2 - 640;
	} else {
		// Position at top-right
		self.healthBarContainer.x = -self.healthBarBg.width / 2;
		self.healthBarContainer.y = -self.sprite.height / 2 - 600;
		self.energyBarContainer.x = -self.energyBarBg.width / 2;
		self.energyBarContainer.y = -self.sprite.height / 2 - 550;
		self.nameLabel.x = 0;
		self.nameLabel.y = -self.sprite.height / 2 - 640;
	}
	// Methods
	self.updateBars = function () {
		var healthRatio = Math.max(0, Math.min(1, self.health / self.maxHealth));
		var energyRatio = Math.max(0, Math.min(1, self.energy / self.maxEnergy));
		// Animate health bar changes
		tween(self.healthBarFg.scale, {
			x: healthRatio
		}, {
			duration: 300
		});
		// Animate energy bar changes
		tween(self.energyBarFg.scale, {
			x: energyRatio
		}, {
			duration: 300
		});
	};
	self.takeDamage = function (amount) {
		self.health = Math.max(0, self.health - amount);
		self.updateBars();
		// Visual feedback
		tween(self.sprite, {
			alpha: 0.2
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(self.sprite, {
					alpha: 1
				}, {
					duration: 100,
					onFinish: function onFinish() {
						// Ensure breathing animation continues after the flash
						if (self.sprite && self.sprite.parent) {
							// Check if sprite is still valid
							self.startBreathingAnimation();
						}
					}
				});
			}
		});
		return self.health <= 0;
	};
	self.useEnergy = function (amount) {
		var canUse = self.energy >= amount;
		if (canUse) {
			self.energy -= amount;
			self.updateBars();
		}
		return canUse;
	};
	self.replenishEnergy = function (amount) {
		self.energy = Math.min(self.maxEnergy, self.energy + amount);
		self.updateBars();
	};
	self.reset = function (newHealth, newEnergy) {
		self.health = newHealth || self.maxHealth;
		self.energy = newEnergy || self.maxEnergy;
		self.updateBars();
	};
	self.setName = function (newName) {
		self.name = newName;
		self.nameLabel.setText(newName);
	};
	self.startBreathingAnimation = function () {
		// If a previous breathing tween exists for this fighter, stop it.
		// This assumes the tween library returns a controllable object with a 'kill' method.
		if (self.breathingTween && typeof self.breathingTween.kill === 'function') {
			self.breathingTween.kill();
		}
		// Ensure the sprite and its scale property are available.
		if (self.sprite && self.sprite.scale) {
			// Reset sprite scale to a base of (1,1) before starting the animation.
			// This ensures the animation is consistent even if called multiple times.
			self.sprite.scale.set(1, 1);
			// Create the tween for the y-scale.
			self.breathingTween = tween(self.sprite.scale, {
				y: 1.03
			},
			// Target y-scale (3% taller)
			{
				duration: 1500,
				// Duration of one half of the animation (e.g., inhale) in milliseconds.
				yoyo: true,
				// Makes the animation reverse automatically (e.g., exhale).
				repeat: Infinity // Loop the animation indefinitely.
			});
		}
	};
	// Initialize bars
	self.updateBars();
	// Start the breathing animation when the fighter is initialized.
	self.startBreathingAnimation();
	return self;
});
var StatusMessage = Container.expand(function () {
	var self = Container.call(this);
	self.text = new Text2("", {
		size: 60,
		fill: 0xFFFFFF
	});
	self.text.anchor.set(0.5, 0.5);
	self.addChild(self.text);
	self.show = function (message, duration) {
		self.text.setText(message);
		self.visible = true;
		if (self.hideTimeout) {
			LK.clearTimeout(self.hideTimeout);
		}
		self.hideTimeout = LK.setTimeout(function () {
			self.visible = false;
			self.hideTimeout = null;
		}, duration || 1500);
	};
	self.visible = false;
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x2c3e50
});

/**** 
* Game Code
****/ 
// Placeholder ID, engine handles actual resource
// Music assets for each level
// Game state
// Assuming a generic ID for now
var currentLevel = 1;
var totalLevels = 10;
var playerTurn = true;
var gameActive = false;
var enemyAttackDelay = 1000;
// Characters
var player;
var enemy;
var enemies = [{
	name: "Qeko",
	health: 70,
	energy: 80,
	damage: 1.0
}, {
	name: "Oramakoma Buramako",
	health: 90,
	energy: 90,
	damage: 1.1
}, {
	name: "Dust2person",
	health: 100,
	energy: 100,
	damage: 1.2
}, {
	name: "Warrior",
	health: 120,
	energy: 100,
	damage: 1.3
}, {
	name: "Veteran",
	health: 130,
	energy: 110,
	damage: 1.4
}, {
	name: "Champion",
	health: 150,
	energy: 120,
	damage: 1.5
}, {
	name: "Master",
	health: 170,
	energy: 130,
	damage: 1.6
}, {
	name: "Grandmaster",
	health: 200,
	energy: 140,
	damage: 1.7
}, {
	name: "Warlord",
	health: 220,
	energy: 150,
	damage: 1.8
}, {
	name: "Arena King",
	health: 250,
	energy: 150,
	damage: 2.0
}];
// Attack options
var attacks = [{
	name: "Quick Strike",
	damage: 10,
	energy: 20,
	description: "A fast, low damage attack"
}, {
	name: "Heavy Blow",
	damage: 25,
	energy: 40,
	description: "A powerful but energy-draining strike"
}, {
	name: "Risky Slash",
	damage: 40,
	energy: 60,
	description: "High damage but very energy intensive"
}, {
	name: "Desperate Attack",
	damage: 60,
	energy: 90,
	description: "All-in attack with massive energy cost"
}];
// UI Elements
var attackButtons = [];
var statusMessage;
var levelDisplay;
var nextLevelButton;
// Initialize the game elements
function initGame() {
	// Add background for current level
	var background = LK.getAsset('background1', {
		anchorX: 0,
		anchorY: 0
	});
	background.isBackground = true; // Mark as background for easy identification
	game.addChild(background);
	// Create player and enemy
	player = new Fighter(true, 150, 100);
	player.setName("Chad Hardwood");
	player.x = 2048 / 4;
	player.y = 2732 / 2 + 100; // Move down to make room for health bars at top
	game.addChild(player);
	enemy = new Fighter(false, enemies[0].health, enemies[0].energy);
	enemy.x = 2048 / 4 * 3;
	enemy.y = 2732 / 2 + 100; // Move down to make room for health bars at top
	enemy.setName(enemies[0].name);
	// Make sure we're using the enemy1 asset for the first level
	enemy.sprite.destroy();
	enemy.sprite = enemy.attachAsset('enemy1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	enemy.startBreathingAnimation(); // Restart animation for the new sprite
	game.addChild(enemy);
	// Create attack buttons
	var buttonContainer = new Container();
	game.addChild(buttonContainer);
	buttonContainer.x = 2048 / 2;
	buttonContainer.y = 2732 - 200;
	for (var i = 0; i < attacks.length; i++) {
		var button = new AttackButton(attacks[i]);
		button.x = (i - 1.5) * 320;
		button.onAttack = handlePlayerAttack;
		attackButtons.push(button);
		buttonContainer.addChild(button);
	}
	// Create status message
	statusMessage = new StatusMessage();
	statusMessage.x = 2048 / 2;
	statusMessage.y = 2732 / 3;
	game.addChild(statusMessage);
	// Create level display
	levelDisplay = new Text2("Level " + currentLevel + "/" + totalLevels, {
		size: 40,
		fill: 0xFFFFFF
	});
	levelDisplay.anchor.set(0.5, 0.5);
	levelDisplay.x = 2048 / 2;
	levelDisplay.y = 80;
	game.addChild(levelDisplay);
	// Create next level button (hidden initially)
	nextLevelButton = new AttackButton({
		name: "NEXT LEVEL",
		damage: 0,
		energy: 0
	});
	nextLevelButton.x = 2048 / 2;
	nextLevelButton.y = 2732 / 2 + 200;
	nextLevelButton.onAttack = startNextLevel;
	nextLevelButton.visible = false;
	game.addChild(nextLevelButton);
	// Start game
	startGame();
}
function startGame() {
	LK.playMusic('level' + currentLevel + 'Music');
	gameActive = true;
	playerTurn = true;
	updateUI();
	statusMessage.show("Battle Start! Your Turn", 1500);
}
function updateUI() {
	// Update level display
	levelDisplay.setText("Level " + currentLevel + "/" + totalLevels);
	// Enable/disable attack buttons based on player's energy
	for (var i = 0; i < attackButtons.length; i++) {
		if (playerTurn && gameActive && player.energy >= attacks[i].energy) {
			attackButtons[i].enable();
		} else {
			attackButtons[i].disable();
		}
	}
	// Show/hide next level button
	// Button is visible if game is not active (round ended), it's not the last level, AND player is still alive
	nextLevelButton.visible = !gameActive && currentLevel < totalLevels && player && player.health > 0;
}
function handlePlayerAttack(attackData) {
	if (!playerTurn || !gameActive) return;
	// Use energy for attack
	if (!player.useEnergy(attackData.energy)) {
		statusMessage.show("Not enough energy!", 1000);
		return;
	}
	// Apply damage to enemy
	var damage = attackData.damage;
	// Random chance for critical hit (20% chance)
	var isCritical = Math.random() < 0.2;
	if (isCritical) {
		damage = Math.floor(damage * 1.5);
		LK.getSound('critical').play();
		statusMessage.show("Critical Hit! " + damage + " damage", 1000);
	} else {
		LK.getSound('hit').play();
		statusMessage.show(attackData.name + "! " + damage + " damage", 1000);
	}
	// Visual feedback
	LK.effects.flashObject(enemy.sprite, 0xff0000, 300);
	// Play specific sound for level 2 enemy damage
	if (currentLevel === 2) {
		LK.getSound('level2EnemyDamage').play();
	}
	// Apply damage
	var defeated = enemy.takeDamage(damage);
	// Create and show blood splatter effect on enemy
	var splatter = new BloodSplatter();
	// Position splatter slightly above the center of the enemy, with some randomness
	splatter.x = enemy.x + (Math.random() - 0.5) * enemy.sprite.width * 0.25; // Random x-offset within 25% of sprite width
	splatter.y = enemy.y - enemy.sprite.height * 0.2 + (Math.random() - 0.5) * (enemy.sprite.height * 0.25); // Positioned towards upper part
	game.addChild(splatter);
	if (defeated) {
		// {2J}
		handleEnemyDefeated();
	} else {
		// End player turn if no energy left
		if (player.energy < 20) {
			endPlayerTurn();
		}
	}
	updateUI();
}
function handleEnemyDefeated() {
	gameActive = false;
	LK.getSound('victory').play();
	if (currentLevel >= totalLevels) {
		// Game completed
		statusMessage.show("Congratulations! You are the Arena Champion!", 3000);
		LK.setTimeout(function () {
			LK.showYouWin();
		}, 3000);
	} else {
		// Level completed
		statusMessage.show("Enemy Defeated! Get ready for the next challenge", 2000);
		LK.setTimeout(function () {
			nextLevelButton.visible = true;
			updateUI();
		}, 2000);
	}
}
function endPlayerTurn() {
	playerTurn = false;
	statusMessage.show("Out of energy! Enemy's turn", 1000);
	// Schedule enemy attack
	LK.setTimeout(enemyAttack, enemyAttackDelay);
	updateUI();
}
function enemyAttack() {
	if (gameActive) {
		// Choose a random attack based on available energy
		var availableAttacks = [];
		for (var i = 0; i < attacks.length; i++) {
			if (enemy.energy >= attacks[i].energy) {
				availableAttacks.push(attacks[i]);
			}
		}
		if (availableAttacks.length === 0) {
			// Enemy has no energy for attacks
			startPlayerTurn();
			return;
		}
		var attack = availableAttacks[Math.floor(Math.random() * availableAttacks.length)];
		// Use energy
		enemy.useEnergy(attack.energy);
		// Calculate damage (apply enemy damage multiplier)
		var enemyDamageMultiplier = enemies[currentLevel - 1].damage;
		var damage = Math.floor(attack.damage * enemyDamageMultiplier);
		// Random chance for player to block (10% chance)
		var isBlocked = Math.random() < 0.1;
		if (isBlocked) {
			damage = Math.floor(damage * 0.5);
			LK.getSound('block').play();
			statusMessage.show("Attack Blocked! " + damage + " damage", 1000);
		} else {
			LK.getSound('hit').play();
			statusMessage.show("Enemy used " + attack.name + "! " + damage + " damage", 1000);
		}
		// Visual feedback
		LK.effects.flashObject(player.sprite, 0xff0000, 300);
		// Apply damage
		var defeated = player.takeDamage(damage);
		// Create and show blood splatter effect on player
		var splatter = new BloodSplatter();
		// Position splatter slightly above the center of the player, with some randomness
		splatter.x = player.x + (Math.random() - 0.5) * player.sprite.width * 0.25; // Random x-offset within 25% of sprite width
		splatter.y = player.y - player.sprite.height * 0.2 + (Math.random() - 0.5) * (player.sprite.height * 0.25); // Positioned towards upper part
		game.addChild(splatter);
		if (defeated) {
			// {3a}
			handlePlayerDefeated();
		} else {
			// Continue enemy attacks if it has energy
			if (enemy.energy >= 20) {
				LK.setTimeout(enemyAttack, enemyAttackDelay);
			} else {
				LK.setTimeout(startPlayerTurn, enemyAttackDelay);
			}
		}
	}
	updateUI();
}
function handlePlayerDefeated() {
	gameActive = false;
	LK.getSound('defeat').play();
	statusMessage.show("You have been defeated!", 2000);
	LK.setTimeout(function () {
		LK.showGameOver();
	}, 2000);
}
function startPlayerTurn() {
	playerTurn = true;
	// Replenish some energy for player
	player.replenishEnergy(30);
	statusMessage.show("Your Turn", 1000);
	updateUI();
}
function startNextLevel() {
	currentLevel++;
	// Update enemy based on current level
	var enemyData = enemies[currentLevel - 1];
	// Update background for new level
	// Remove previous background and add new one
	for (var i = 0; i < game.children.length; i++) {
		if (game.children[i].isBackground) {
			game.removeChild(game.children[i]);
			break;
		}
	}
	var background = LK.getAsset('background' + currentLevel, {
		anchorX: 0,
		anchorY: 0
	});
	background.isBackground = true; // Mark as background for easy identification
	game.addChildAt(background, 0); // Add to the bottom layer
	// Remove old enemy sprite and create new one with current level's asset
	enemy.sprite.destroy();
	enemy.sprite = enemy.attachAsset('enemy' + currentLevel, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	enemy.startBreathingAnimation(); // Restart animation for the new sprite
	enemy.setName(enemyData.name);
	enemy.reset(enemyData.health, enemyData.energy);
	// Replenish player health and energy
	player.reset(player.maxHealth, player.maxEnergy); // Reset to full health and energy at start of each level
	// Reset game state
	LK.playMusic('level' + currentLevel + 'Music');
	gameActive = true;
	playerTurn = true;
	nextLevelButton.visible = false;
	// Show level message
	statusMessage.show("Level " + currentLevel + ": " + enemyData.name, 1500);
	updateUI();
}
// Initialize the game
initGame();

===================================================================
--- original.js
+++ change.js
@@ -52,8 +52,37 @@
 		self.bg.interactive = true;
 	};
 	return self;
 });
+var BloodSplatter = Container.expand(function () {
+	var self = Container.call(this);
+	// Attach the blood splatter asset
+	var effectGraphics = self.attachAsset('bloodSplatterEffect', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.alpha = 1;
+	// Randomize scale and rotation for a bit of variety
+	var randomScale = 0.5 + Math.random() * 0.7; // Scale between 0.5 and 1.2
+	self.scale.set(randomScale);
+	self.rotation = Math.random() * Math.PI * 2; // Random rotation
+	var lifeFrames = 25; // Effect duration in frames (थोड़ा 0.5 सेकंड से कम 60FPS पर)
+	// This update function will be called by the LK engine automatically
+	// as long as the BloodSplatter instance is added to a displayed container (e.g., game)
+	self.update = function () {
+		lifeFrames--;
+		// Fade out the effect
+		self.alpha = Math.max(0, lifeFrames / 25);
+		if (lifeFrames <= 0) {
+			// Remove from parent container and destroy when life is up
+			if (self.parent) {
+				self.parent.removeChild(self);
+			}
+			self.destroy(); // Clean up the PIXI object
+		}
+	};
+	return self;
+});
 var Fighter = Container.expand(function (isPlayer, maxHealth, maxEnergy) {
 	var self = Container.call(this);
 	self.isPlayer = isPlayer || false;
 	self.maxHealth = maxHealth || 100;
@@ -249,8 +278,9 @@
 
 /**** 
 * Game Code
 ****/ 
+// Placeholder ID, engine handles actual resource
 // Music assets for each level
 // Game state
 // Assuming a generic ID for now
 var currentLevel = 1;
@@ -454,9 +484,16 @@
 		LK.getSound('level2EnemyDamage').play();
 	}
 	// Apply damage
 	var defeated = enemy.takeDamage(damage);
+	// Create and show blood splatter effect on enemy
+	var splatter = new BloodSplatter();
+	// Position splatter slightly above the center of the enemy, with some randomness
+	splatter.x = enemy.x + (Math.random() - 0.5) * enemy.sprite.width * 0.25; // Random x-offset within 25% of sprite width
+	splatter.y = enemy.y - enemy.sprite.height * 0.2 + (Math.random() - 0.5) * (enemy.sprite.height * 0.25); // Positioned towards upper part
+	game.addChild(splatter);
 	if (defeated) {
+		// {2J}
 		handleEnemyDefeated();
 	} else {
 		// End player turn if no energy left
 		if (player.energy < 20) {
@@ -523,9 +560,16 @@
 		// Visual feedback
 		LK.effects.flashObject(player.sprite, 0xff0000, 300);
 		// Apply damage
 		var defeated = player.takeDamage(damage);
+		// Create and show blood splatter effect on player
+		var splatter = new BloodSplatter();
+		// Position splatter slightly above the center of the player, with some randomness
+		splatter.x = player.x + (Math.random() - 0.5) * player.sprite.width * 0.25; // Random x-offset within 25% of sprite width
+		splatter.y = player.y - player.sprite.height * 0.2 + (Math.random() - 0.5) * (player.sprite.height * 0.25); // Positioned towards upper part
+		game.addChild(splatter);
 		if (defeated) {
+			// {3a}
 			handlePlayerDefeated();
 		} else {
 			// Continue enemy attacks if it has energy
 			if (enemy.energy >= 20) {