/**** 
* 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);
	self.particles = [];
	var numParticles = 10 + Math.floor(Math.random() * 10); // 10 to 19 particles
	var baseLife = 30 + Math.random() * 30; // Approx 0.5 to 1 second life at 60FPS
	self.update = function () {
		for (var i = self.particles.length - 1; i >= 0; i--) {
			var p = self.particles[i];
			p.life--;
			if (p.life <= 0) {
				self.removeChild(p.sprite);
				p.sprite.destroy(); // Destroy the individual particle sprite
				self.particles.splice(i, 1); // Remove from the array
			} else {
				p.sprite.x += p.vx;
				p.sprite.y += p.vy;
				p.sprite.rotation += p.rotationSpeed;
				p.sprite.alpha = Math.max(0, p.life / p.initialLife); // Fade out
				// Apply some friction/drag to slow down particles
				p.vx *= 0.97;
				p.vy *= 0.97;
				// Optional: apply gravity
				// p.vy += 0.1; 
			}
		}
		if (self.particles.length === 0) {
			// All particles are gone, remove the container itself
			if (self.parent) {
				self.parent.removeChild(self);
			}
			self.destroy(); // Destroy the BloodSplatter container
		}
	};
	for (var i = 0; i < numParticles; i++) {
		// Use LK.getAsset as we are creating multiple instances dynamically
		var particleSprite = LK.getAsset('bloodSplatterEffect', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Randomize scale for each particle to be smaller than original effect
		var scale = 0.05 + Math.random() * 0.2; // e.g., 0.05 to 0.25
		particleSprite.scale.set(scale);
		particleSprite.rotation = Math.random() * Math.PI * 2; // Random initial rotation
		var angle = Math.random() * Math.PI * 2; // Random direction
		var speed = 3 + Math.random() * 7; // Random speed (3 to 10 pixels/frame)
		var particle = {
			sprite: particleSprite,
			vx: Math.cos(angle) * speed,
			vy: Math.sin(angle) * speed,
			rotationSpeed: (Math.random() - 0.5) * 0.3,
			// Random rotation speed (radians/frame)
			life: baseLife * (0.7 + Math.random() * 0.6),
			// Vary lifetime slightly per particle
			initialLife: 0 // Will be set after life is determined
		};
		particle.initialLife = particle.life; // Store initial life for alpha calculation
		self.addChild(particleSprite);
		self.particles.push(particle);
	}
	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();
		// --- Auto-heal and block chance boost if health drops below 30% ---
		if (!self._boosted && self.health / self.maxHealth < 0.3) {
			// Only boost once per drop below 30%
			self._boosted = true;
			self.replenishEnergy(70);
			self._blockChanceBoost = 0.6; // 60% extra block chance
			// Optional: show a status message if this is the player
			if (self.isPlayer && typeof statusMessage !== "undefined") {
				statusMessage.show("Emergency boost! +70 energy, block chance up!", 1200);
			}
		} else if (self.health / self.maxHealth >= 0.3) {
			// Reset boost if healed above 30%
			self._boosted = false;
			self._blockChanceBoost = 0;
		}
		// 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
****/ 
// Assuming a generic ID for now
// Game state
// Music assets for each level
// Placeholder ID, engine handles actual resource
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: "Rockey",
	health: 120,
	energy: 100,
	damage: 1.3
}, {
	name: "Zikko",
	health: 130,
	energy: 110,
	damage: 1.4
}, {
	name: "Sweetie",
	health: 150,
	energy: 120,
	damage: 1.5
}, {
	name: "Master Baitor",
	health: 170,
	energy: 130,
	damage: 1.6
}, {
	name: "Grandmaster",
	health: 200,
	energy: 140,
	damage: 1.7
}, {
	name: "The God",
	health: 220,
	energy: 150,
	damage: 1.8
}, {
	name: "Woody CHADMAN",
	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);
		// Level 9 & 10: 7% chance to fully heal enemy after critical hit
		if ((currentLevel === 9 || currentLevel === 10) && Math.random() < 0.07) {
			enemy.health = enemy.maxHealth;
			enemy.updateBars();
			statusMessage.show("The enemy miraculously healed to full health!", 1200);
		}
	} else {
		LK.getSound('hit').play();
		statusMessage.show(attackData.name + "! " + damage + " damage", 1000);
	}
	// Visual feedback
	// --- Fast approach-and-return animation for player attacking enemy ---
	var originalPlayerX = player.x;
	var originalEnemyX = enemy.x;
	var approachDistance = Math.abs(enemy.x - player.x) * 0.4; // Move 40% of the distance
	var approachDuration = 120;
	var returnDuration = 180;
	// Swap to attack asset for player
	var oldPlayerSprite = player.sprite;
	oldPlayerSprite.visible = false;
	var attackSprite = player.attachAsset('playerAttack', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	attackSprite.x = 0;
	attackSprite.y = 0;
	player.addChild(attackSprite);
	player.sprite = attackSprite;
	// Move player towards enemy
	tween(player, {
		x: player.x + approachDistance
	}, {
		duration: approachDuration,
		easing: tween.cubicOut,
		onFinish: function onFinish() {
			// Move player back to original position
			tween(player, {
				x: originalPlayerX
			}, {
				duration: returnDuration,
				easing: tween.cubicIn,
				onFinish: function onFinish() {
					// Remove attack sprite and restore original
					player.removeChild(attackSprite);
					attackSprite.destroy();
					oldPlayerSprite.visible = true;
					player.sprite = oldPlayerSprite;
					player.startBreathingAnimation();
				}
			});
		}
	});
	// Move enemy slightly towards player (for impact effect)
	tween(enemy, {
		x: enemy.x - approachDistance * 0.15
	}, {
		duration: approachDuration,
		easing: tween.cubicOut,
		onFinish: function onFinish() {
			tween(enemy, {
				x: originalEnemyX
			}, {
				duration: returnDuration,
				easing: tween.cubicIn
			});
		}
	});
	LK.effects.flashObject(enemy.sprite, 0xff0000, 300);
	// Play specific sound for level 2 enemy damage
	if (currentLevel === 2) {
		LK.getSound('level2EnemyDamage').play();
	}
	// Enemy block chance: 10% base, +60% if health < 30%
	var enemyBlockChance = 0.1 + (enemy._blockChanceBoost || 0);
	var enemyBlocked = Math.random() < enemyBlockChance;
	if (enemyBlocked) {
		damage = Math.floor(damage * 0.5);
		LK.getSound('block').play();
		statusMessage.show("Enemy Blocked! " + damage + " damage", 1000);
	}
	// 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;
	// Play special death sound for level 2 enemy
	if (currentLevel === 2) {
		LK.getSound('level2EnemyDeath').play();
	}
	// Play special death sound for level 3 enemy
	if (currentLevel === 3) {
		LK.getSound('level3EnemyDeath').play();
	}
	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);
		// 2% instant kill chance for enemy attacks at level 6 and below
		var instantKill = false;
		if (currentLevel <= 6 && Math.random() < 0.02) {
			damage = player.health; // Set damage to current health for instant kill
			instantKill = true;
		}
		// Random chance for player to block (10% base chance, +60% if player health < 30%)
		var blockChance = 0.1 + (player._blockChanceBoost || 0);
		var isBlocked = Math.random() < blockChance;
		if (isBlocked) {
			damage = Math.floor(damage * 0.5);
			LK.getSound('block').play();
			statusMessage.show("Attack Blocked! " + damage + " damage", 1000);
		} else if (instantKill) {
			LK.getSound('critical').play();
			statusMessage.show("Fatal Strike! Instant defeat!", 1200);
		} else {
			LK.getSound('hit').play();
			statusMessage.show("Enemy used " + attack.name + "! " + damage + " damage", 1000);
		}
		// Visual feedback
		// --- Fast approach-and-return animation for enemy attacking player ---
		var originalEnemyX = enemy.x;
		var originalPlayerX = player.x;
		var approachDistance = Math.abs(enemy.x - player.x) * 0.4; // Move 40% of the distance
		var approachDuration = 120;
		var returnDuration = 180;
		// Swap to attack asset for enemy
		var oldEnemySprite = enemy.sprite;
		oldEnemySprite.visible = false;
		var attackAssetName = 'enemy' + currentLevel + 'Attack';
		var attackSprite = enemy.attachAsset(attackAssetName, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		attackSprite.x = 0;
		attackSprite.y = 0;
		enemy.addChild(attackSprite);
		enemy.sprite = attackSprite;
		// Move enemy towards player
		tween(enemy, {
			x: enemy.x - approachDistance
		}, {
			duration: approachDuration,
			easing: tween.cubicOut,
			onFinish: function onFinish() {
				// Move enemy back to original position
				tween(enemy, {
					x: originalEnemyX
				}, {
					duration: returnDuration,
					easing: tween.cubicIn,
					onFinish: function onFinish() {
						// Remove attack sprite and restore original
						enemy.removeChild(attackSprite);
						attackSprite.destroy();
						oldEnemySprite.visible = true;
						enemy.sprite = oldEnemySprite;
						enemy.startBreathingAnimation();
					}
				});
			}
		});
		// Move player slightly towards enemy (for impact effect)
		tween(player, {
			x: player.x + approachDistance * 0.15
		}, {
			duration: approachDuration,
			easing: tween.cubicOut,
			onFinish: function onFinish() {
				tween(player, {
					x: originalPlayerX
				}, {
					duration: returnDuration,
					easing: tween.cubicIn
				});
			}
		});
		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();
	LK.getSound('gameOverDefeat').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
	if (currentLevel > 7) {
		// Give extra 20 health for player after level 7
		player.maxHealth += 20;
	}
	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
@@ -325,12 +325,12 @@
 
 /**** 
 * Game Code
 ****/ 
-// Placeholder ID, engine handles actual resource
-// Music assets for each level
-// Game state
 // Assuming a generic ID for now
+// Game state
+// Music assets for each level
+// Placeholder ID, engine handles actual resource
 var currentLevel = 1;
 var totalLevels = 10;
 var playerTurn = true;
 var gameActive = false;
@@ -671,11 +671,11 @@
 		enemy.useEnergy(attack.energy);
 		// Calculate damage (apply enemy damage multiplier)
 		var enemyDamageMultiplier = enemies[currentLevel - 1].damage;
 		var damage = Math.floor(attack.damage * enemyDamageMultiplier);
-		// 3% instant kill chance for enemy attacks at level 6 and below
+		// 2% instant kill chance for enemy attacks at level 6 and below
 		var instantKill = false;
-		if (currentLevel <= 6 && Math.random() < 0.03) {
+		if (currentLevel <= 6 && Math.random() < 0.02) {
 			damage = player.health; // Set damage to current health for instant kill
 			instantKill = true;
 		}
 		// Random chance for player to block (10% base chance, +60% if player health < 30%)