/**** 
* Classes
****/ 
// BackgroundContainer class to handle background elements
var BackgroundContainer = Container.expand(function () {
	var self = Container.call(this);
	var background = self.attachAsset('gameBackground', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2048 / 2,
		y: 2732 / 2,
		width: 2048,
		height: 2732
	});
	return self;
});
var EnemyBullet = Container.expand(function (shooter, target) {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('enemyBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 50;
	self.shooter = shooter;
	self.target = target;
	self._move_migrated = function () {
		var dx = self.target.x - self.shooter.x;
		var dy = self.target.y - self.shooter.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		self.x += self.speed * dx / distance;
		self.y += self.speed * dy / distance;
	};
});
// ForegroundContainer class to handle foreground elements
var ForegroundContainer = Container.expand(function () {
	var self = Container.call(this);
	// Add foreground elements here
	return self;
});
// ForegroundContainer class to handle foreground elements
// MidgroundContainer class to handle midground elements
var MidgroundContainer = Container.expand(function () {
	var self = Container.call(this);
	// Add midground elements here
	return self;
});
var Platform = Container.expand(function () {
	var self = Container.call(this);
	var platformGraphics = self.attachAsset('Platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var Platform_Enemy = Container.expand(function () {
	var self = Container.call(this);
	var platformGraphics = self.attachAsset('Platform_Enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
// Projectile class
var Projectile = Container.expand(function (shooter, target) {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 50;
	self.shooter = shooter;
	self.target = target;
	self._move_migrated = function () {
		var dx = self.target.x - self.shooter.x;
		var dy = self.target.y - self.shooter.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		self.x += self.speed * dx / distance;
		self.y += self.speed * dy / distance;
	};
});
// Assets will be automatically generated based on usage in the code.
// Tank class
var Tank = Container.expand(function (isEnemy) {
	var self = Container.call(this);
	this.isEnemy = isEnemy || false;
	self.baseHP = 100; // Base health points of the tank
	self.HP = self.baseHP; // Current health points of the tank
	self.Accuracy = 0.80; // Accuracy of the tank's shots
	self.minDmg = 10; // Minimum damage the tank can inflict
	self.maxDmg = 20; // Maximum damage the tank can inflict
	self.isEnemy = self.isEnemy ? true : false;
	var tankGraphics = self.attachAsset(self.isEnemy ? 'enemyTank' : 'tank', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.direction = self.isEnemy ? 2 : 0; // 0: up, 1: right, 2: down, 3: left
	self.shoot = function (targetTank) {
		// Calculate damage based on minDmg and maxDmg
		var damage = Math.floor(Math.random() * (self.maxDmg - self.minDmg + 1)) + self.minDmg;
		// Simulate accuracy
		var hit = Math.random() < self.Accuracy;
		if (hit) {
			LK.getSound('Shoot_Player').play();
			// Apply damage to targetTank.HP
			targetTank.HP -= damage;
			gameState.isAnimating = true;
		}
	};
});
// TankStatsHUD class for displaying tank stats
var TankStatsHUD = Container.expand(function (x, y, tank) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	self.tank = tank;
	// Initialize HUD texts as properties to avoid redundancy
	// Initialize HUD texts as properties to avoid redundancy
	// Helper function to create HUD text elements
	function createHUDTextElement() {
		return self.addChild(new Text2('', {
			size: statTextProperties.size,
			fill: statTextProperties.fill,
			stroke: statTextProperties.stroke,
			strokeThickness: statTextProperties.strokeThickness,
			width: statTextProperties.width,
			align: statTextProperties.align
		}));
	}
	self.hpText = createHUDTextElement();
	self.accuracyText = createHUDTextElement();
	self.minDmgText = createHUDTextElement();
	self.maxDmgText = createHUDTextElement();
	// Set initial positions
	self.hpText.y = 0;
	self.accuracyText.y = 130;
	self.minDmgText.y = 260;
	self.maxDmgText.y = 390;
	// Consolidated method to update HUD with tank stats
	self.updateHUD = function () {
		// Update all stats in a single method to streamline HUD updates
		self.hpText.setText("Health: ".concat(self.tank.HP));
		self.accuracyText.setText("Accuracy: ".concat(Math.round(self.tank.Accuracy * 100), "%"));
		self.minDmgText.setText("Min Dmg: ".concat(self.tank.minDmg));
		self.maxDmgText.setText("Max Dmg: ".concat(self.tank.maxDmg));
	};
});

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

/**** 
* Game Code
****/ 
// Define roundText for displaying current round
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
function _defineProperty(e, r, t) {
	return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
		value: t,
		enumerable: !0,
		configurable: !0,
		writable: !0
	}) : e[r] = t, e;
}
function _toPropertyKey(t) {
	var i = _toPrimitive(t, "string");
	return "symbol" == _typeof(i) ? i : i + "";
}
function _toPrimitive(t, r) {
	if ("object" != _typeof(t) || !t) {
		return t;
	}
	var e = t[Symbol.toPrimitive];
	if (void 0 !== e) {
		var i = e.call(t, r || "default");
		if ("object" != _typeof(i)) {
			return i;
		}
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}
// Initialize gameState before defining roundText
var backgroundContainer = new BackgroundContainer();
var midgroundContainer = new MidgroundContainer();
var platform = new Platform();
platform.x = 2048 / 2;
platform.y = 2732 / 2 + 1050;
midgroundContainer.addChild(platform);
var platformEnemy = new Platform_Enemy();
platformEnemy.x = 2048 / 2;
platformEnemy.y = 2732 / 2 - 1050;
midgroundContainer.addChild(platformEnemy);
var foregroundContainer = new ForegroundContainer();
game.addChild(backgroundContainer);
game.addChild(midgroundContainer);
game.addChild(foregroundContainer);
var gameState = {
	currentRound: 1,
	tanks: [] // Initialize tanks as an empty array
	// other gameState properties
};
var roundText = new Text2('Round: ' + gameState.currentRound.toString(), {
	size: 100,
	fill: "#ffffff",
	stroke: "#000000",
	strokeThickness: 15,
	anchorX: 0.5,
	anchorY: 0.5
});
foregroundContainer.addChild(roundText);
roundText.x = 2048 / 2 - 200;
roundText.y = 2732 / 2;
var statTextProperties = {
	size: 60,
	fill: "#ffffff",
	stroke: "#000000",
	strokeThickness: 10,
	width: 400,
	align: "center"
};
// Define a single source of truth for stat upgrades
var statUpgrades = {
	'HP': 20,
	// Match player's tank upgrade value
	'Accuracy': 0.04,
	// Match player's tank upgrade value
	'MinDmg': 5,
	// Match player's tank upgrade value
	'MaxDmg': 5 // Match player's tank upgrade value
};
function applyStatUpgrade(selectedUpgrade, tank) {
	if (statUpgrades.hasOwnProperty(selectedUpgrade)) {
		var upgradeValue = statUpgrades[selectedUpgrade];
		switch (selectedUpgrade) {
			case 'HP':
				tank.baseHP += upgradeValue;
				tank.HP += upgradeValue; // Increase current HP by upgradeValue instead of setting it to new baseHP
				break;
			case 'Accuracy':
				tank.Accuracy = Math.min(1.0, tank.Accuracy + upgradeValue);
				break;
			case 'MinDmg':
				tank.minDmg += upgradeValue;
				break;
			case 'MaxDmg':
				tank.maxDmg += upgradeValue;
				break;
		}
	}
	// Listen for stat change events to dynamically update available upgrades and refresh upgrade buttons
	game.on('statChange', function (tank) {
		gameState.upgradesAvailable = allUpgrades.filter(function (upgrade) {
			if (upgrade === 'Accuracy' && tank.Accuracy >= 1.0) {
				return false; // Exclude Accuracy if it's already at or above 100%
			}
			if (upgrade === 'MinDmg' && tank.minDmg >= tank.maxDmg) {
				return false; // Exclude MinDmg if it's equal to or greater than MaxDmg
			}
			if (upgrade === 'MaxDmg' && tank.maxDmg <= tank.minDmg) {
				return false; // Exclude MaxDmg if it's not greater than MinDmg
			}
			return true; // Include all other upgrades
		});
		handleUpgradesAndButtons(); // Refresh upgrade buttons based on updated available upgrades
	});
}
// This function now applies to both player and enemy tanks using the same stat upgrades
// Consolidated upgrade logic into a single function for clarity and maintainability
function applyUpgrades(tank) {
	// Consolidated upgrade logic into a single function for clarity and maintainability
	// This function now applies to both player and enemy tanks using the same stat upgrades
	// Dynamically update and manage upgrade button visibility within this function
	gameState.upgradesAvailable.forEach(function (upgrade) {
		applyStatUpgrade(upgrade, tank);
	});
	// Refresh upgrade buttons to reflect current game state and available upgrades
	handleUpgradesAndButtons();
}
// Consolidated function to handle upgrades and dynamically create buttons
function handleUpgradesAndButtons() {
	// Remove existing upgrade buttons before creating new ones
	game.children.forEach(function (child) {
		if (child.id && child.id.startsWith('Upgrade_')) {
			child.destroy();
		}
	});
	LK.getSound('Upgrade_Screen').play();
	// Updated to check and update upgrade button visibility based on tank stats
	// Emit statChange event whenever a stat is upgraded
	game.emit('statChange', tank);
	gameState.upgradesAvailable = allUpgrades.filter(function (upgrade) {
		if (upgrade === 'Accuracy' && gameState.playerTank.Accuracy >= 1.0) {
			return false; // Exclude Accuracy if it's already at or above 100%
		}
		if (upgrade === 'MinDmg') {
			return gameState.playerTank.minDmg < gameState.playerTank.maxDmg;
		}
		// After MaxDmg upgrade, check if MinDmg upgrade should be visible
		if (upgrade === 'MaxDmg') {
			// After MaxDmg upgrade, check if MinDmg upgrade should be visible
			if (gameState.playerTank.minDmg < gameState.playerTank.maxDmg) {
				// Ensure MinDmg upgrade button is visible if conditions are met
				if (!gameState.upgradesAvailable.includes('MinDmg')) {
					gameState.upgradesAvailable.push('MinDmg');
				}
			}
		}
		return true; // Include all other upgrades
	}).forEach(function (upgrade, index) {
		var upgradeBtn = new Container();
		var btnGraphics = upgradeBtn.attachAsset('Upgrade_Btn', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Positioning and event listener for upgradeBtn omitted for brevity
		game.addChild(upgradeBtn);
	});
}
// Helper function to select a random upgrade for the enemy
function selectRandomUpgrade(tank) {
	var validUpgrades = gameState.upgradesAvailable.filter(function (upgrade) {
		// Example condition to filter out upgrades, can be expanded
		return !(upgrade === 'Accuracy' && tank.Accuracy >= 1.0);
	});
	var randomIndex = Math.floor(Math.random() * validUpgrades.length);
	return validUpgrades[randomIndex];
}
// Initialize gameState before defining tanks to avoid 'currentRound' being undefined
// Redundant upgrade text display code successfully removed
// Function to reset game state for a new round
function resetGameStateForNewRound() {
	// Select a single random upgrade for the enemy ensuring only one stat is upgraded per round
	function selectSingleRandomUpgradeForEnemy() {
		// Ensure only one stat is upgraded per round
		if (gameState.currentRound === gameState.lastUpgradedRound) {
			return;
		} // Exit if upgrade already applied this round
		var validUpgrades = Object.keys(statUpgrades).filter(function (upgrade) {
			// Conditions to filter out maximized stats
			if (upgrade === 'Accuracy' && gameState.enemyTank.Accuracy >= 1.0) {
				return false;
			}
			if (upgrade === 'HP' && gameState.enemyTank.HP >= gameState.enemyTank.baseHP) {
				return false;
			}
			if (upgrade === 'MinDmg' && (gameState.enemyTank.minDmg >= gameState.enemyTank.maxDmg - 5 || gameState.enemyTank.minDmg === gameState.enemyTank.maxDmg)) {
				return false;
			}
			if (upgrade === 'MaxDmg' && (gameState.enemyTank.maxDmg >= 50 || gameState.enemyTank.minDmg === gameState.enemyTank.maxDmg)) {
				return false;
			}
			return true;
		});
		if (validUpgrades.length > 0) {
			var randomUpgrade = validUpgrades[Math.floor(Math.random() * validUpgrades.length)];
			applyStatUpgrade(randomUpgrade, gameState.enemyTank);
			gameState.lastUpgradedRound = gameState.currentRound; // Mark this round as upgraded
		}
	}
	// Reset the flag to false at the end of the round to allow for a single upgrade in the next round
	gameState.playerTurn = true; // Give the turn back to the player
	gameState.roundIncremented = false; // Reset the round increment flag
	gameState.isAnimating = false; // Ensure no animations are running
	// Define startingHP for both tanks to ensure it's available for resetting
	// Clear all bullets from the previous round to prevent applying damage from the last bullet
	bullets.forEach(function (bullet) {
		bullet.destroy();
	});
	bullets = [];
	// Reset both tanks' HP to their baseHP at the beginning of a new round
	gameState.playerTank.HP = gameState.playerTank.baseHP;
	gameState.enemyTank.HP = gameState.enemyTank.baseHP;
	// Update both player and enemy HUDs to reflect the reset state
	playerTankHUD.updateHUD();
	enemyTankHUD.updateHUD();
}
// Consolidated function for damage calculation and text display
function calculateDamage(shooter, target) {
	var hit = Math.random() < shooter.Accuracy;
	if (hit) {
		var damage = Math.floor(Math.random() * (shooter.maxDmg - shooter.minDmg + 1)) + shooter.minDmg;
		target.HP = Math.max(0, target.HP - damage);
		// Initiate shake effect
		var originalX = target.x;
		var originalY = target.y;
		var shakeDuration = 200; // Duration in milliseconds
		var shakeStartTime = Date.now();
		var shake = function shake() {
			if (Date.now() - shakeStartTime < shakeDuration) {
				// Randomly adjust target's position to simulate stronger shaking
				target.x = originalX + Math.random() * 20 - 10; // Shake range -10 to 10 pixels on x-axis
				target.y = originalY + Math.random() * 20 - 10; // Shake range -10 to 10 pixels on y-axis
				LK.setTimeout(shake, 16); // Approximately 60 frames per second
			} else {
				// Reset target's position after shaking
				target.x = originalX;
				target.y = originalY;
			}
		};
		shake();
		displayDamageText(damage, target.x, target.y);
		if (target === gameState.playerTank) {
			playerTankHUD.updateHUD();
		}
		return true;
	} else {
		displayMissIndicator(target.x, target.y);
		return false;
	}
}
// Helper function to display damage text
function displayDamageText(damage, x, y) {
	var damageText = new Text2(damage.toString(), {
		size: 150,
		// Increased size from 120 to 180
		fill: "#ff0000",
		stroke: "#000000",
		strokeThickness: 15,
		anchorX: 0.5,
		anchorY: 0.5
	});
	damageText.position.set(x - 80, y - 80);
	game.addChild(damageText);
	LK.setTimeout(function () {
		return damageText.destroy();
	}, 600);
}
// Helper function to display miss indicator
function displayMissIndicator(x, y) {
	var missIndicator = LK.getAsset('miss', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: x,
		y: y
	});
	game.addChild(missIndicator);
	LK.setTimeout(function () {
		return missIndicator.destroy();
	}, 1000);
}
// Define triggerPlayerShoot function globally to ensure it's accessible throughout the script
function triggerPlayerShoot() {
	LK.getSound('Shoot_Player').play();
	var projectile = new Projectile(playerTank, enemyTank);
	projectile.x = playerTank.x;
	projectile.y = playerTank.y - 150; // Positioning logic for shooting upwards
	game.addChild(projectile);
	bullets.push(projectile);
	gameState.isAnimating = true; // Indicate an action is taking place, requiring animation.
}
// Define triggerEnemyShoot function globally to ensure it's accessible throughout the script
// Define triggerEnemyShoot function globally to ensure it's accessible throughout the script
function triggerEnemyShoot() {
	LK.getSound('Shoot_Enemy').play();
	var enemyProjectile = new EnemyBullet(gameState.enemyTank, gameState.playerTank);
	enemyProjectile.x = gameState.enemyTank.x;
	enemyProjectile.y = gameState.enemyTank.y + 100; // Adjusted positioning for enemy shooting logic
	game.addChild(enemyProjectile);
	bullets.push(enemyProjectile);
	gameState.isAnimating = true; // Ensure this is set to true to prevent immediate subsequent actions
}
// Initialize gameState with unique identifiers to prevent global scope conflicts
var allUpgrades = ['HP', 'Accuracy', 'MinDmg', 'MaxDmg'];
// Define shootingInterval in the global scope to manage shooting intervals
var shootingInterval = null;
// Define bullets array in the global scope for easy access and manipulation
var bullets = [];
// Initialize player and enemy tanks within the gameState to ensure a single source of truth
gameState.playerTank = new Tank(false); // Player's tank
gameState.enemyTank = new Tank(true); // Enemy's tank
// Initialize player tank
var playerTank = new Tank(false); // Player's tank
playerTank.x = 1024; // Center horizontally
playerTank.y = 2732 - 300; // Moved 100 pixels higher
gameState.playerTank = playerTank; // Assign playerTank to gameState
game.addChild(gameState.playerTank);
gameState.tanks.push(gameState.playerTank);
game.addChild(gameState.playerTank);
gameState.tanks.push(gameState.playerTank);
// Initialize enemy tank
var enemyTank = new Tank(true); // Enemy's tank
enemyTank.x = 1024; // Center horizontally
enemyTank.y = 300; // Moved 100 pixels lower
gameState.enemyTank = enemyTank; // Assign enemyTank to gameState
game.addChild(gameState.enemyTank);
gameState.tanks.push(gameState.enemyTank);
game.addChild(gameState.enemyTank);
gameState.tanks.push(gameState.enemyTank);
// Instantiate TankStatsHUD for the player tank
var playerTankHUD = new TankStatsHUD(-600, -515, gameState.playerTank); // Center above the player tank
LK.gui.bottom.addChild(playerTankHUD);
// Instantiate TankStatsHUD for the enemy tank and ensure it's visible from the start
var enemyTankHUD = new TankStatsHUD(-600, +50, gameState.enemyTank); // Position at the top of the screen
enemyTankHUD.updateHUD(); // Update HUD to make it visible from the start
LK.gui.top.addChild(enemyTankHUD);
// Handle touch events to rotate and move the tank
// Removed tank rotation on screen tap
// Define a function to manage the shooting interval
function manageShootingInterval(action) {
	if (action === 'start') {
		// Clear existing interval if any
		if (shootingInterval) {
			manageShootingInterval('stop'); // Use the dedicated function to stop shooting
		}
		// Start a new shooting interval
		shootingInterval = LK.setInterval(function () {
			if (gameState.isAnimating || gameState.playerTank.HP <= 0 || gameState.enemyTank.HP <= 0) {
				return; // Prevent firing if any condition is met.
			}
			if (gameState.currentRound === 1 || gameState.playerTurn) {
				triggerPlayerShoot();
			} else {
				triggerEnemyShoot();
			}
		}, 1000);
	} else if (action === 'stop') {
		// Clear the shooting interval
		if (shootingInterval) {
			LK.clearInterval(shootingInterval);
		}
	}
}
// Initially start the shooting interval
manageShootingInterval('start');
// Move bullets
LK.on('tick', function () {
	// Implement a pre-check at the beginning of this function to halt actions if a tank's HP is 0.
	if (gameState.playerTank.HP <= 0 || gameState.enemyTank.HP <= 0) {
		// Consider implementing logic here to pause the game and trigger any end-of-round or game over logic.
		gameState.isAnimating = false; // Halt animations.
		return; // Exit the tick function early.
	}
	playerTankHUD.updateHUD();
	var _loop = function _loop() {
			if (bullets[i]) {
				bullets[i]._move_migrated();
			}
			// Check for collision with tanks
			if (bullets[i].intersects(playerTank) && bullets[i] instanceof EnemyBullet) {
				// Correctly identify shooter as enemyTank and target as playerTank for damage calculation
				if (calculateDamage(enemyTank, playerTank)) {
					// Ensure enemyTank is the shooter and playerTank is the target
					playerTankHUD.updateHUD(); // Update player tank HUD stats
					// Check if either tank's HP reaches 0 to pause game and show upgrades
					if (playerTank.HP === 0) {
						gameState.isPaused = true; // Stop all actions immediately
						LK.clearInterval(shootingInterval); // Stop shooting immediately
						game.off('down'); // Disable movement immediately
						LK.showGameOver(); // End game if player tank HP drops to 0
					} else if (enemyTank.HP === 0) {
						// Delay pausing the game until after the bullet is destroyed
						bullets[i].destroy(); // Remove bullet from game
						bullets.splice(i, 1); // Remove bullet from bullets array
						gameState.isPaused = true; // Stop all actions immediately
						LK.clearInterval(shootingInterval); // Stop shooting immediately
						game.off('down'); // Disable movement immediately
						LK.setTimeout(showUpgradeOptions, 100); // Delay showing upgrade options to ensure bullet is removed
					}
				}
				bullets[i].destroy(); // Remove bullet from game
				bullets.splice(i, 1); // Remove bullet from bullets array
				gameState.playerTurn = true; // Switch turn to player
				gameState.isAnimating = false; // End animation state
				return {
					v: void 0
				}; // Exit the loop
			} else if (bullets[i].intersects(enemyTank) && bullets[i] instanceof Projectile) {
				// Invoke calculateDamage for player bullet hitting enemy tank
				if (calculateDamage(gameState.playerTank, enemyTank)) {
					enemyTankHUD.updateHUD(); // Refresh enemy tank HUD stats
					if (enemyTank.HP === 0) {
						LK.getSound('Upgrade_Screen').play(); // Play Upgrade_Screen sound when enemy tank reaches 0 HP
						// Set game state to paused
						gameState.isPaused = true;
						// Clear shooting interval to pause shooting
						LK.clearInterval(shootingInterval);
						// Disable movement by removing event listeners
						game.off('down');
						// Display upgrade options for the player to select
						// Initialize upgrade buttons for player selection
						// Dynamically update the list of available upgrades based on current tank stats
						// After applying the upgrade, update the player and enemy tank HUD to reflect changes
						playerTankHUD.updateHUD();
						enemyTankHUD.updateHUD();
						// Filter upgrades based on new stats
						gameState.upgradesAvailable = allUpgrades.filter(function (upgrade) {
							if (upgrade === 'Accuracy' && gameState.playerTank.Accuracy >= 1.0) {
								return false; // Exclude Accuracy if it's already at or above 100%
							}
							if (upgrade === 'MinDmg' && gameState.playerTank.minDmg >= gameState.playerTank.maxDmg) {
								return false; // Exclude MinDmg if it's equal to or greater than MaxDmg
							}
							return true; // Include all other upgrades
						});
						// Iterate over the filtered list of upgrades to display upgrade buttons
						// Define individual positions for each upgrade button
						var upgradePositions = {
							'HP': {
								x: 80,
								y: 2040
							},
							'Accuracy': {
								x: 80,
								y: 2225
							},
							'MinDmg': {
								x: 80,
								y: 2410
							},
							'MaxDmg': {
								x: 80,
								y: 2595
							}
						};
						gameState.upgradesAvailable.forEach(function (upgrade) {
							var pos = upgradePositions[upgrade];
							var upgradeBtn = LK.getAsset('Upgrade_Btn', {
								x: pos.x,
								y: pos.y,
								anchorX: 0.5,
								anchorY: 0.5,
								id: 'Upgrade_' + upgrade
							});
							upgradeBtn.on('down', function () {
								LK.getSound('Upgrade_Btn').play(); // Play Upgrade_Btn sound when any upgrade button is pressed
								if (upgrade === 'HP') {
									LK.getSound('Upg_HP').play(); // Play Upg_HP sound when HP upgrade button is pressed
								} else if (upgrade === 'Accuracy') {
									LK.getSound('Upg_Acc').play(); // Play Upg_Acc sound when Accuracy upgrade button is pressed
								} else if (upgrade === 'MinDmg') {
									LK.getSound('Upg_Dmg_Min').play(); // Play Upg_Dmg_Min sound when MinDmg upgrade button is pressed
								} else if (upgrade === 'MaxDmg') {
									LK.getSound('Upg_Dmg_Max').play(); // Play Upg_Dmg_Max sound when MaxDmg upgrade button is pressed
								}
								gameState.playerSelectedUpgrade = upgrade;
								applyStatUpgrade(gameState.playerSelectedUpgrade, gameState.playerTank);
								var filteredUpgrades = gameState.upgradesAvailable.filter(function (upgrade) {
									return !(upgrade === 'Accuracy' && gameState.enemyTank.Accuracy >= 1.0);
								});
								var randomUpgradeIndex = Math.floor(Math.random() * filteredUpgrades.length);
								gameState.enemySelectedUpgrade = filteredUpgrades[randomUpgradeIndex];
								applyStatUpgrade(gameState.enemySelectedUpgrade, gameState.enemyTank);
								// Remove all upgrade buttons after selection
								game.children = game.children.filter(function (child) {
									return !child.id || !child.id.startsWith('Upgrade_');
								});
								manageShootingInterval('start');
								gameState.isPaused = false;
								gameState.playerTurn = true;
								gameState.isAnimating = false;
								gameState.currentRound += 1; // Increment the round number
								roundText.setText('Round: ' + gameState.currentRound.toString()); // Update the round text
								resetGameStateForNewRound();
							});
							game.addChild(upgradeBtn);
						});
						// Ensure round management is correctly handled at the end of each round
						if (!gameState.isAnimating && gameState.playerTank.HP > 0 && gameState.enemyTank.HP > 0) {
							manageGameRound(); // Correctly increment and manage round transitions only when conditions are met
						}
						return {
							v: void 0
						}; // Exit the loop to avoid executing further code in this tick
					}
				}
				bullets[i].destroy();
				bullets.splice(i, 1);
				gameState.playerTurn = false; // Switch to enemy's turn after player bullet hits
				triggerEnemyShoot(); // Trigger enemy to shoot immediately after player's bullet hits
				return {
					v: void 0
				};
			}
			// Remove bullets that go off-screen
			if (bullets[i].y < 0) {
				bullets[i].destroy();
				bullets.splice(i, 1);
				// gameState.isAnimating = false; // Moved to a more appropriate location after enemy's turn
				gameState.playerTurn = !gameState.playerTurn;
				// Reset gameState.isAnimating to false after ensuring all animations and hit calculations are complete
				if (!gameState.playerTurn) {
					LK.setTimeout(function () {
						gameState.isAnimating = false;
					}, 1000); // Assuming 1 second is enough for the enemy's bullet to reach the player or go off-screen
				}
			}
		},
		_ret;
	for (var i = bullets.length - 1; i >= 0; i--) {
		_ret = _loop();
		if (_ret) {
			return _ret.v;
		}
	}
});
function showUpgradeOptions() {
	LK.getSound('Upgrade_Screen').play();
	// Display upgrade options for the player to select
	gameState.upgradesAvailable.forEach(function (upgrade, index) {
		// Removed incorrect positioning logic for upgrade buttons to ensure they appear correctly relative to their corresponding stats
		upgradeBtn.on('down', function () {
			gameState.playerSelectedUpgrade = upgrade;
			// Define applyPlayerUpgrade function to apply the selected upgrade to the player's tank
			function applyPlayerUpgrade() {
				applyStatUpgrade(gameState.playerSelectedUpgrade, gameState.playerTank);
				// Directly call handleUpgradesAndButtons to update upgrade button visibility based on stat changes
				handleUpgradesAndButtons();
				// Listen for stat change events to dynamically update available upgrades and refresh upgrade buttons
				game.on('statChange', function (tank) {
					gameState.upgradesAvailable = allUpgrades.filter(function (upgrade) {
						if (upgrade === 'Accuracy' && tank.Accuracy >= 1.0) {
							return false; // Exclude Accuracy if it's already at or above 100%
						}
						if (upgrade === 'MinDmg' && tank.minDmg >= tank.maxDmg) {
							return false; // Exclude MinDmg if it's equal to or greater than MaxDmg
						}
						if (upgrade === 'MaxDmg' && tank.maxDmg <= tank.minDmg) {
							return false; // Exclude MaxDmg if it's not greater than MinDmg
						}
						return true; // Include all other upgrades
					});
					handleUpgradesAndButtons(); // Refresh upgrade buttons based on updated available upgrades
				});
			}
			// Dynamically create upgrade buttons based on updated available upgrades
			gameState.upgradesAvailable.forEach(function (upgrade, index) {
				var upgradeBtn = LK.getAsset('Upgrade_Btn', {
					// Correct positioning logic will be applied elsewhere
					id: 'Upgrade_' + upgrade // Assign a unique ID based on the upgrade type
				});
				upgradeBtn.on('down', function () {
					gameState.playerSelectedUpgrade = upgrade;
					applyStatUpgrade(gameState.playerSelectedUpgrade, gameState.playerTank);
					// Filter out Accuracy upgrade if enemy's Accuracy is already at 100%, then randomly select and apply an upgrade
					var filteredUpgrades = gameState.upgradesAvailable.filter(function (upgrade) {
						return !(upgrade === 'Accuracy' && gameState.enemyTank.Accuracy >= 1.0);
					});
					var randomUpgradeIndex = Math.floor(Math.random() * filteredUpgrades.length);
					gameState.enemySelectedUpgrade = filteredUpgrades[randomUpgradeIndex];
					applyStatUpgrade(gameState.enemySelectedUpgrade, gameState.enemyTank);
					// Hide all upgrade buttons and texts
					game.children.forEach(function (child) {
						if (child.id && child.id.startsWith('Upgrade_')) {
							child.destroy();
						}
					});
					// Restart shooting interval after upgrade selection using the dedicated function
					manageShootingInterval('start');
					// Resume game after upgrade selection
					gameState.isPaused = false;
					// Ensure Game State is Correctly Managed
					gameState.playerTurn = true; // It's player's turn after selecting an upgrade
					gameState.isAnimating = false; // No animations are running at the start of a new round
					resetGameStateForNewRound();
				});
				game.addChild(upgradeBtn);
				var upgradeText = new Text2(upgrade, {
					size: 40,
					fill: "#000000",
					x: upgradeBtn.x,
					y: upgradeBtn.y,
					anchorX: 0.5,
					anchorY: 0.5,
					id: 'Upgrade_Text_' + upgrade // Assign a unique ID for the text based on the upgrade type
				});
				game.addChild(upgradeText);
			});
			// Resume game after upgrade selection
			gameState.isPaused = false; // Allow game actions to continue
			// Clear existing shooting interval before setting a new one
			if (shootingInterval) {
				LK.clearInterval(shootingInterval);
			}
			// Set up a new shooting interval
			shootingInterval = LK.setInterval(function () {
				if (!gameState.isPaused) {
					if (gameState.playerTurn) {
						triggerPlayerShoot();
					} else {
						triggerEnemyShoot();
					}
				}
			}, 1000); // Adjust timing as necessary
			// Re-attach event listeners for player movement and actions
			game.on('down', function (x, y, obj) {
				// Movement and action logic here, ensuring it only executes when the game is not paused
			});
			resetGameStateForNewRound(); // Reset the game state for a new round
			gameState.playerTurn = true; // Player starts shooting after selecting an upgrade
		});
		game.addChild(upgradeBtn);
		var upgradeText = new Text2(upgrade, {
			size: 40,
			fill: "#000000",
			x: upgradeBtn.x,
			y: upgradeBtn.y,
			anchorX: 0.5,
			anchorY: 0.5
		});
		game.addChild(upgradeText);
	});
	function applyRandomUpgradeToEnemy() {
		var filteredUpgrades = gameState.upgradesAvailable.filter(function (upgrade) {
			return !(upgrade === 'Accuracy' && gameState.enemyTank.Accuracy >= 1.0);
		});
		var randomUpgrade = filteredUpgrades[Math.floor(Math.random() * filteredUpgrades.length)];
		applyStatUpgrade(randomUpgrade, gameState.enemyTank);
	}
	// Define roundText for displaying current round
	var roundText = new Text2('Round: ' + gameState.currentRound.toString(), {
		size: 60,
		fill: "#ffffff",
		stroke: "#000000",
		strokeThickness: 10,
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2048 / 2,
		y: 2732 / 2
	});
	foregroundContainer.addChild(roundText);
	// Ensure round management is handled in a single function to prevent multiple increments
	function manageGameRound() {
		if (!gameState.roundIncremented) {
			gameState.roundIncremented = true; // Ensure round is only incremented once per logical game round
		}
		roundText.setText('Round: ' + gameState.currentRound.toString()); // Update the round text to display the new round number
		LK.effects.flashScreen(0x00FF00, 500); // Flash the screen green to indicate round advancement
	}
	// Call manageGameRound() where necessary instead of directly manipulating gameState.currentRound
}
; // Display upgrade options for the player to select

===================================================================
--- original.js
+++ change.js
@@ -232,9 +232,9 @@
 // Define a single source of truth for stat upgrades
 var statUpgrades = {
 	'HP': 20,
 	// Match player's tank upgrade value
-	'Accuracy': 0.02,
+	'Accuracy': 0.04,
 	// Match player's tank upgrade value
 	'MinDmg': 5,
 	// Match player's tank upgrade value
 	'MaxDmg': 5 // Match player's tank upgrade value