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

/**** 
* Classes
****/ 
// BackgroundContainer class
var BackgroundContainer = Container.expand(function () {
	var self = Container.call(this);
});
//<Assets used in the game will automatically appear here>
//<Write imports for supported plugins here>
// Enemy class to handle enemy logic
var Enemy = Container.expand(function (assetType, hpIncrement) {
	var self = Container.call(this);
	if (!assetType) {
		console.error("Asset type is undefined");
		return;
	}
	var enemyGraphics = cachedEnemyAssets[assetType]; // Reuse cached asset
	enemyGraphics.anchor.set(0.5, 0.5); // Set anchor to center
	self.addChild(enemyGraphics); // Attach the cached asset to the enemy
	self.init = function () {
		self.x = 2048 / 2;
		self.y = 2732 / 2 - 500;
		// Initialize the enemy's HP
		self.hpIncrement = hpIncrement;
		self.hp = 10 + self.hpIncrement;
		// Add a text to display the enemy's HP
		self.hpText = new Text2("", {
			size: 200,
			fill: 0xFFFFFF
		});
		self.hpText.anchor.set(0.5, 0.5);
		self.hpText.y = -700; // Move the text higher
		self.addChild(self.hpText);
		// Update the enemy's HP text
		if (self.hpText) {
			self.hpText.setText("HP: " + self.hp);
		}
	};
	self.init(); // Ensure init is called during construction
});
// ForegroundContainer class
var ForegroundContainer = Container.expand(function () {
	var self = Container.call(this);
});
// MidgroundContainer class
var MidgroundContainer = Container.expand(function () {
	var self = Container.call(this);
});
// Peon class to represent the player character
var Peon = Container.expand(function () {
	var self = Container.call(this);
	// Attach the 'peon' asset to the Peon
	var peonGraphics = self.attachAsset('peon', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Initialize the Peon's position on the wheel
	self.init = function (wheel) {
		self.x = wheel.x;
		self.y = wheel.y;
		self.currentPosition = Math.floor(Math.random() * 8); // Peon's current position on the wheel
		self.hp = 200; // Peon's HP
		self.hpText = new Text2('Peon: ' + self.hp, {
			size: 150,
			fill: 0xFFFFFF
		});
		self.hpText.anchor.set(0.5, 0);
		self.hpText.y += 1000;
		LK.gui.top.addChild(self.hpText);
		self.x += self.currentPosition * 250; // Position Peon on the random cell
	};
	// Spin the Peon around the wheel
	self.spin = function (wheel) {
		self.steps = Math.floor(Math.random() * (maxTiles - startingMovingTiles + 1)) + startingMovingTiles;
		var _spinStep = function spinStep() {
			self.currentPosition = (self.currentPosition + 1) % 8;
			self.x = wheel.x + self.currentPosition * 250;
			if (self.currentPosition == 0) {
				self.x = wheel.x;
			}
			self.steps--;
			currentInterval *= multiplier;
			if (self.steps <= 0) {
				self.x = wheel.x + self.currentPosition * 250;
				var cell = wheel.cells[self.currentPosition];
				if (cell.actionType === 'heal') {
					self.hp += cell.damage;
					if (self.hp > 200) {
						self.hp = 200;
					}
					self.hpText.setText('Peon: ' + self.hp);
					var healText = new Text2('+' + cell.damage, {
						size: 150,
						fill: 0x00FF00
					});
					healText.anchor.set(0.5, 0.5);
					healText.x = self.hpText.x + 250;
					healText.y = self.hpText.y;
					LK.gui.top.addChild(healText);
					tween(healText, {
						alpha: 0,
						y: healText.y - 50
					}, {
						duration: 1000,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							healText.destroy();
						}
					});
				} else {
					var projectile = projectilePool.getProjectile();
					projectile.init(self.x, self.y, enemy.x, enemy.y, 10, cell.damage, self.currentPosition);
					if (!projectile.parent) {
						game.addChild(projectile);
					}
				}
				wheel.isSpinning = false;
				var _deductHp = function deductHp() {
					if (cell.actionType !== 'heal') {
						var damage = Math.floor(Math.random() * (maxDamage - minDamage + 1)) + minDamage;
						self.hp -= damage;
						if (self.hp < 0) {
							self.hp = 0;
						}
						self.hpText.setText('Peon: ' + self.hp);
						if (self.hp === 0) {
							LK.showGameOver();
						}
					}
				};
				_deductHp();
				currentInterval = startingInterval;
			} else {
				LK.setTimeout(_spinStep, currentInterval);
			}
		};
		_spinStep();
	};
});
// Current interval for the spin
// Player class to handle player logic
var Player = Container.expand(function () {
	var self = Container.call(this);
	// Attach the 'peon' asset to the Player
	var playerGraphics = self.attachAsset('peon', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Initialize the Player's position on the wheel
	self.init = function (wheel) {
		self.x = wheel.x;
		self.y = wheel.y;
		self.currentPosition = Math.floor(Math.random() * 8); // Player's current position on the wheel
		self.hp = 200; // Player's HP
		self.hpText = new Text2('Player: ' + self.hp, {
			size: 150,
			fill: 0xFFFFFF //Optional (this is the default string)
		});
		self.hpText.anchor.set(0.5, 0); // Sets anchor to the center of the top edge of the text.
		self.hpText.y += 1000; // Move the text 1000 pixels lower
		LK.gui.top.addChild(self.hpText);
		self.x += self.currentPosition * 250; // Position Player on the random cell
	};
	// Spin the Player around the wheel
	self.spin = function (wheel) {
		// Generate a random integer between 10 and 15
		self.steps = Math.floor(Math.random() * (maxTiles - startingMovingTiles + 1)) + startingMovingTiles;
		var _spinStep = function spinStep() {
			self.currentPosition = (self.currentPosition + 1) % 8; // Update Player's current position
			self.x = wheel.x + self.currentPosition * 250; // Move Player one cell to the right
			if (self.currentPosition == 0) {
				// If Player reaches Cell 8, loop back to Cell 1
				self.x = wheel.x;
			}
			self.steps--;
			currentInterval *= multiplier; // Increase the interval by the multiplier
			if (self.steps <= 0) {
				// Player lands on the final cell
				self.x = wheel.x + self.currentPosition * 250;
				// Check the action type of the landed cell
				var cell = wheel.cells[self.currentPosition];
				if (cell.actionType === 'heal') {
					self.hp += cell.damage;
					if (self.hp > 200) {
						self.hp = 200;
					}
					self.hpText.setText('Player: ' + self.hp);
					// Create and display heal amount text
					var healText = new Text2('+' + cell.damage, {
						size: 150,
						fill: 0x00FF00 // Green color for heal
					});
					healText.anchor.set(0.5, 0.5);
					healText.x = self.hpText.x + 250;
					healText.y = self.hpText.y; // Position it directly over the player's HP text
					LK.gui.top.addChild(healText);
					// Tween animation for heal text
					tween(healText, {
						alpha: 0,
						y: healText.y - 50 // Move slightly up during fade out
					}, {
						duration: 1000,
						// 1 second duration
						easing: tween.easeOut,
						onFinish: function onFinish() {
							healText.destroy();
						}
					});
				} else {
					var projectile = projectilePool.getProjectile();
					projectile.init(self.x, self.y, enemy.x, enemy.y, 10, cell.damage, self.currentPosition);
					if (!projectile.parent) {
						game.addChild(projectile);
					}
				}
				wheel.isSpinning = false; // Set isSpinning to false after the spin is complete
				// Deduct damage from player's HP after player stops
				var _deductHp = function deductHp() {
					if (cell.actionType !== 'heal') {
						var damage = Math.floor(Math.random() * (maxDamage - minDamage + 1)) + minDamage;
						self.hp -= damage;
						if (self.hp < 0) {
							self.hp = 0;
						}
						self.hpText.setText('Player: ' + self.hp);
						if (self.hp === 0) {
							LK.showGameOver();
						}
					}
				};
				_deductHp();
				currentInterval = startingInterval; // Reset the interval to the starting interval
			} else {
				LK.setTimeout(_spinStep, currentInterval); // Schedule the next step
			}
		};
		_spinStep(); // Start the spin
	};
});
// Projectile class to represent the projectiles shot by the cells
var Projectile = Container.expand(function () {
	var self = Container.call(this);
	// Attach the 'projectile' asset to the Projectile
	var projectileGraphics = self.attachAsset('projectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Initialize the Projectile's position and target
	self.init = function (startX, startY, targetX, targetY, speed, damage, cellIndex) {
		self.x = startX;
		self.y = startY;
		self.targetX = targetX;
		self.targetY = targetY;
		self.speed = speed * 3; // Increase the bullet speed
		var baseDamage = damage;
		var totalDamageBoost = upgradeState.global.totalDamageBoost;
		self.cellIndex = cellIndex >= 0 && cellIndex < wheel.cells.length ? cellIndex : 0;
		var specificCellBoost = upgradeState.individual.specificCellBoosts[self.cellIndex] || 0;
		var categoricalBoost = 0;
		var cell = wheel.cells[self.cellIndex];
		if (cell && cell.type === 'minor') {
			categoricalBoost = upgradeState.categorical.minorDamageBoost;
		} else if (cell && cell.type === 'major') {
			categoricalBoost = upgradeState.categorical.majorDamageBoost;
		} else if (cell && cell.type === 'critical') {
			categoricalBoost = upgradeState.categorical.criticalDamageBoost;
		}
		self.cellIndex = cellIndex >= 0 && cellIndex < wheel.cells.length ? cellIndex : 0;
		self.damage = baseDamage + totalDamageBoost + specificCellBoost + categoricalBoost;
		self.active = true; // Mark projectile as active
	};
	// Move the Projectile towards its target
	self.update = function () {
		if (!self.active) {
			return;
		} // Skip update if not active
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var dist = calculateDistance(self.x, self.y, self.targetX, self.targetY);
		if (dist < self.speed) {
			self.x = self.targetX;
			self.y = self.targetY;
			self.deactivate(); // Deactivate when reaching target
		} else {
			self.x += dx * self.speed / dist;
			self.y += dy * self.speed / dist;
			// Check if the projectile has intersected with the enemy
			if (self.intersects(enemy)) {
				// Deal damage to the enemy
				enemy.hp -= self.damage;
				// Display damage text on enemy
				var damageText = new Text2(self.damage.toString(), {
					size: 150,
					fill: 0xFF0000,
					stroke: 0x000000,
					strokeThickness: 10
				});
				damageText.stroke = 0x000000;
				damageText.strokeThickness = 10;
				damageText.anchor.set(0.5, 0.5);
				damageText.x = 0;
				damageText.y = -300;
				LK.gui.center.addChild(damageText);
				// Tween animation for appearance
				tween(damageText, {
					alpha: 1,
					y: enemy.y - 50
				}, {
					duration: 800,
					easing: tween.easeOut
				});
				// Tween animation for fade out
				tween(damageText, {
					alpha: 0,
					y: damageText.y - 100 // Move slightly up during fade out
				}, {
					duration: 800,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						damageText.destroy();
					}
				});
				// Update the enemy's HP text
				if (enemy) {
					if (!enemy.hpText) {
						enemy.hpText = new Text2("", {
							size: 200,
							fill: 0xFFFFFF
						});
						enemy.hpText.anchor.set(0.5, 0.5);
						enemy.hpText.y = -700;
						enemy.addChild(enemy.hpText);
					}
					if (enemy.hpText) {
						if (enemy.hpText) {
							enemy.hpText.setText("HP: " + enemy.hp); // Update the enemy's HP text
						}
					}
				}
				self.deactivate(); // Deactivate the projectile
				// Add shake animation to the enemy
				var shake = 20;
				var shakeSpeed = 15;
				var originalEnemyX = enemy.x; // Save the original position of the enemy
				var shakeInterval = LK.setInterval(function () {
					shake *= -1;
					enemy.x += shake;
					shakeSpeed--;
					if (shakeSpeed <= 0) {
						LK.clearInterval(shakeInterval);
						enemy.x = originalEnemyX; // Reset the enemy's position after the shake animation ends
					}
				}, shakeSpeed);
				// If enemy's HP reaches 0, destroy the enemy and play explosion animation
				if (enemy.hp <= 0) {
					enemy.destroy();
					gameState = "upgradeMode";
					pauseGame();
					upgradeManager.enterUpgradeMode();
					// Create a custom explosion animation
					if (enemy.assetType) {
						var explosion = self.attachAsset(enemy.assetType, {
							anchorX: 0.5,
							anchorY: 0.5
						});
						explosion.x = enemy.x;
						explosion.y = enemy.y;
						explosion.scaleX = 2;
						explosion.scaleY = 2;
						explosion.alpha = 0.5;
						game.addChild(explosion);
						var _fadeOut = function fadeOut() {
							explosion.alpha -= 0.05;
							if (explosion.alpha <= 0) {
								explosion.destroy();
							} else {
								LK.setTimeout(_fadeOut, 50);
							}
						};
						_fadeOut();
					}
					// Create a new enemy
					enemy = createNewEnemy(); // Properly instantiated
					if (!enemy.hpText) {
						enemy.hpText = new Text2("", {
							size: 200,
							fill: 0xFFFFFF
						});
						enemy.hpText.anchor.set(0.5, 0.5);
						enemy.hpText.y = -700;
						enemy.addChild(enemy.hpText);
					}
					enemy.hpText.setText("HP: " + enemy.hp); // Update the enemy's HP text
					game.addChild(enemy);
				}
			}
		}
	};
	// Deactivate the projectile and return it to the pool
	self.deactivate = function () {
		self.active = false;
		self.x = -1000; // Move off-screen
		self.y = -1000; // Move off-screen
	};
});
// SpinningWheel class to handle spinning mechanics
var SpinningWheel = Container.expand(function () {
	var self = Container.call(this);
	self.cells = [];
	self.isSpinning = false;
	// Initialize the wheel with cells
	self.init = function () {
		self.cells = [{
			baseDamage: 10,
			damage: 10,
			// Initialize damage
			type: 'minor',
			actionType: 'damage'
		}, {
			baseDamage: 25,
			damage: 25,
			// Initialize damage
			type: 'major',
			actionType: 'damage'
		}, {
			baseDamage: 10,
			damage: 10,
			// Initialize damage
			type: 'minor',
			actionType: 'damage'
		}, {
			baseDamage: 100,
			damage: 100,
			// Initialize damage
			type: 'critical',
			actionType: 'damage'
		}, {
			baseDamage: 10,
			damage: 10,
			// Initialize damage
			type: 'minor',
			actionType: 'damage'
		}, {
			baseDamage: 25,
			damage: 25,
			// Initialize damage
			type: 'major',
			actionType: 'damage'
		}, {
			baseDamage: 10,
			damage: 10,
			// Initialize damage
			type: 'minor',
			actionType: 'damage'
		}, {
			baseDamage: 50,
			damage: 50,
			// Initialize damage
			type: 'heal',
			actionType: 'heal'
		}];
		for (var i = 0; i < self.cells.length; i++) {
			var cellDisplay = self.attachAsset('tile', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: i * 250 // Increase space between cells
			});
			self.addChild(cellDisplay);
			// Link the display object to the data object
			self.cells[i].display = cellDisplay;
			// Add text to each cell to display the damage value
			var damageText = new Text2(self.cells[i].damage.toString(), {
				size: 50,
				fill: 0xFFFFFF
			});
			damageText.name = 'damageText'; // Unique identifier
			damageText.name = 'damageText'; // Assign a unique name
			damageText.anchor.set(0.5, 0.5);
			cellDisplay.addChild(damageText);
			// Link the display object to the data object
			self.cells[i].display = cellDisplay;
		}
	};
	// Spin the Player around the wheel
	self.spin = function (player) {
		if (!self.isSpinning) {
			self.isSpinning = true;
			player.spin(self);
		}
	};
});
// Initialize UpgradeManager
var UpgradeManager = Container.expand(function (wheel) {
	var self = Container.call(this);
	self.wheel = wheel; // Store the wheel instance
	self.availableUpgrades = upgradeOptions;
	self.generateUpgradeOptions = function () {
		return getRandomUpgrades();
	};
	self.applyUpgrade = function (selectedUpgrade) {
		switch (selectedUpgrade.type) {
			case 'increaseDamage':
				// Update upgradeState based on the upgrade description
				if (selectedUpgrade.description.includes('all damage cells')) {
					upgradeState.global.totalDamageBoost = Math.min(upgradeState.global.totalDamageBoost + selectedUpgrade.value, 1000);
				} else if (selectedUpgrade.description.includes('minor cells')) {
					upgradeState.categorical.minorDamageBoost = Math.min(upgradeState.categorical.minorDamageBoost + selectedUpgrade.value, 500);
				} else if (selectedUpgrade.description.includes('major cells')) {
					upgradeState.categorical.majorDamageBoost += selectedUpgrade.value;
				} else if (selectedUpgrade.description.includes('critical cell')) {
					upgradeState.categorical.criticalDamageBoost += selectedUpgrade.value;
				} else if (selectedUpgrade.description.includes('one random cell')) {
					var randomCell = Math.floor(Math.random() * 8);
					if (!upgradeState.individual.specificCellBoosts[randomCell]) {
						upgradeState.individual.specificCellBoosts[randomCell] = 0;
					}
					upgradeState.individual.specificCellBoosts[randomCell] = Math.min(upgradeState.individual.specificCellBoosts[randomCell] + selectedUpgrade.value, 200);
				}
				console.log("Updated upgradeState:", upgradeState);
				console.log("Global Boost:", upgradeState.global.totalDamageBoost);
				console.log("Categorical Boosts:", upgradeState.categorical);
				console.log("Specific Cell Boosts:", upgradeState.individual.specificCellBoosts);
				break;
			case 'increaseHP':
				if (target && typeof target.hp !== 'undefined') {
					target.hp += selectedUpgrade.value;
					if (target.hp > 200) {
						target.hp = 200;
					}
				} else {
					console.error('Target is undefined or does not have an hp property');
				}
				break;
			case 'increaseSpeed':
				if (target && typeof target.speed !== 'undefined') {
					target.speed += selectedUpgrade.value;
				} else {
					console.error('Target is undefined or does not have a speed property');
				}
				break;
			default:
				console.error('Unknown upgrade type');
		}
	};
	self.refreshCellDamage = function () {
		console.log("refreshCellDamage called"); // Log function call
		if (!self.wheel || !self.wheel.cells) {
			console.error("Wheel or its cells are not initialized.");
			// Only return if critical initialization issues exist
			return;
		}
		for (var i = 0; i < self.wheel.cells.length; i++) {
			var cell = self.wheel.cells[i];
			var totalDamageBoost = upgradeState.global.totalDamageBoost;
			var specificCellBoost = upgradeState.individual.specificCellBoosts[i] || 0;
			var categoricalBoost = 0;
			if (cell.type === 'minor') {
				categoricalBoost = upgradeState.categorical.minorDamageBoost;
			} else if (cell.type === 'major') {
				categoricalBoost = upgradeState.categorical.majorDamageBoost;
			} else if (cell.type === 'critical') {
				categoricalBoost = upgradeState.categorical.criticalDamageBoost;
			}
			var effectiveDamage = cell.baseDamage + totalDamageBoost + specificCellBoost + categoricalBoost;
			console.log("Cell ".concat(i, " (").concat(cell.type, ") new damage: ").concat(effectiveDamage));
			cell.damage = effectiveDamage;
			// Update damageText
			var damageText = cell.display.children.find(function (child) {
				return child.name === 'damageText';
			});
			if (damageText) {
				damageText.setText(effectiveDamage.toString());
			} else {
				console.error("damageText not found for cell ".concat(i));
			}
		}
	};
	self.enterUpgradeMode = function () {
		var options = self.generateUpgradeOptions();
		var upgradeUI = new UpgradeUI();
		upgradeUI.init(options);
		game.addChild(upgradeUI);
	};
});
// UpgradeUI class to handle upgrade selection interface
var UpgradeUI = Container.expand(function () {
	var self = Container.call(this);
	self.upgradeOptions = [];
	// Initialize the UI with two upgrade options
	self.init = function (options) {
		self.upgradeOptions = options;
		self.displayOptions();
	};
	// Display the upgrade options
	self.displayOptions = function () {
		for (var i = 0; i < 2; i++) {
			var optionContainer = new Container(); // Create a container for each option
			optionContainer.x = 1024; // Center horizontally
			optionContainer.y = 1700 + i * 200; // Move options 700 pixels lower
			var optionText = new Text2(self.upgradeOptions[i].description, {
				size: 100,
				fill: 0xFFFFFF
			});
			optionText.anchor.set(0.5, 0.5);
			optionContainer.addChild(optionText); // Add text to the container
			optionContainer.interactive = true; // Make the container interactive
			optionContainer.on('down', function (selectedUpgrade) {
				// Use closure to capture the correct upgrade
				return function () {
					console.log("Upgrade option clicked:", selectedUpgrade.description); // Log the click event
					self.selectUpgrade(selectedUpgrade);
				};
			}(self.upgradeOptions[i])); // Pass the correct upgrade option
			self.addChild(optionContainer); // Add the container to the UI
		}
	};
	// Handle upgrade selection
	self.selectUpgrade = function (selectedUpgrade) {
		console.log("Selected upgrade:", selectedUpgrade.description); // Log the selected upgrade
		upgradeManager.applyUpgrade(selectedUpgrade);
		// Ensure cell damage is updated after applying upgrade
		if (!upgradeManager.refreshCalled) {
			upgradeManager.refreshCellDamage();
			upgradeManager.refreshCalled = true;
		}
		self.destroy(); // Close the UI
		gameState = "playing"; // Resume the game
		resumeGame(); // Restore game interactivity
	};
});

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

/**** 
* Game Code
****/ 
// Centralized state for tracking upgrades
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 ownKeys(e, r) {
	var t = Object.keys(e);
	if (Object.getOwnPropertySymbols) {
		var o = Object.getOwnPropertySymbols(e);
		r && (o = o.filter(function (r) {
			return Object.getOwnPropertyDescriptor(e, r).enumerable;
		})), t.push.apply(t, o);
	}
	return t;
}
function _objectSpread(e) {
	for (var r = 1; r < arguments.length; r++) {
		var t = null != arguments[r] ? arguments[r] : {};
		r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
			_defineProperty(e, r, t[r]);
		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
		});
	}
	return e;
}
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);
}
var upgradeState = {
	global: {
		totalDamageBoost: 0
	},
	categorical: {
		minorDamageBoost: 0,
		majorDamageBoost: 0,
		criticalDamageBoost: 0
	},
	individual: {
		specificCellBoosts: {}
	}
};
// Initialize gameState to manage game states
// UpgradeManager class to handle upgrades
var gameState = "playing"; // Possible states: playing, paused, upgradeMode
// Centralized data structure for upgrade options
var upgradeOptions = [{
	type: 'increaseDamage',
	value: 5,
	description: '+5 to all damage cells'
}, {
	type: 'increaseDamage',
	value: 50,
	description: '+50 to one random cell'
}, {
	type: 'increaseDamage',
	value: 10,
	description: '+10 to minor cells only'
}, {
	type: 'increaseDamage',
	value: 25,
	description: '+25 to major cells only'
}, {
	type: 'increaseDamage',
	value: 100,
	description: '+100 to critical cell only'
}];
function shuffleArray(array) {
	for (var i = array.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var _ref = [array[j], array[i]];
		array[i] = _ref[0];
		array[j] = _ref[1];
	}
}
function getRandomUpgrades() {
	shuffleArray(upgradeOptions);
	return upgradeOptions.slice(0, 2);
}
var upgradeManager = new UpgradeManager(wheel);
var wheel = new SpinningWheel();
if (midgroundContainer) {
	midgroundContainer.addChild(wheel);
} else {
	console.error("midgroundContainer is not initialized.");
}
wheel.init();
wheel.x = 150; // Initial x position
wheel.y = 2500; // Space cells horizontally
game.addChild(wheel);
upgradeManager.wheel = wheel; // Assign wheel reference to UpgradeManager
upgradeManager.enterUpgradeMode = upgradeManager.enterUpgradeMode.bind(upgradeManager);
// Function to pause the game
function pauseGame() {
	// Logic to pause animations, input, and timers
	console.log("Game paused");
}
// Function to trigger the upgrade system UI
function triggerUpgradeUI(options) {
	// Logic to display upgrade options to the player
	console.log("Upgrade UI triggered with options:", options);
	// Display options in a UI for the player to select
	// This is a placeholder for the actual UI implementation
}
// Function to resume the game
function resumeGame() {
	// Logic to resume animations, input, and timers
	console.log("Game resumed");
}
// Example usage: Generate upgrade options and apply one to the Peon
var upgradeOptions = upgradeManager.generateUpgradeOptions();
var selectedUpgrade = upgradeOptions[0]; // Assume player selects the first option
upgradeManager.applyUpgrade(selectedUpgrade);
// ProjectilePool class to manage projectile instances
// Helper function to calculate distance between two points
// Cache enemy assets for reuse
// ProjectilePool class to manage projectile instances
var CELL_ACTIONS = {
	DAMAGE_10: {
		damage: 10,
		actionType: 'damage'
	},
	DAMAGE_25: {
		damage: 25,
		actionType: 'damage'
	},
	DAMAGE_100: {
		damage: 100,
		actionType: 'damage'
	},
	HEAL_50: {
		damage: 50,
		actionType: 'heal'
	}
};
function calculateDistance(x1, y1, x2, y2) {
	return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
}
var cachedEnemyAssets = {
	enemy: LK.getAsset('enemy', {}),
	enemy_2: LK.getAsset('enemy_2', {}),
	enemy_3: LK.getAsset('enemy_3', {})
};
var ProjectilePool = function ProjectilePool() {
	this.pool = [];
	this.getProjectile = function () {
		for (var i = 0; i < this.pool.length; i++) {
			if (!this.pool[i].active) {
				return this.pool[i];
			}
		}
		if (this.pool.length < this.maxPoolSize) {
			var newProjectile = new Projectile();
			this.pool.push(newProjectile);
			return newProjectile;
		}
		return null; // Return null if pool is full
	};
	this.releaseProjectile = function (projectile) {
		projectile.deactivate();
	};
};
var projectilePool = new ProjectilePool();
projectilePool.maxPoolSize = 10; // Set maximum pool size
// ProjectilePool class to manage projectile instances
// Global timing variables
// Initialize spinning wheel
var startingInterval = 2; // Starting interval for the spin
var multiplier = 1.3; // Multiplier for the interval increase
var currentInterval = startingInterval;
var startingMovingTiles = 11; // Starting moving tiles
var maxTiles = 17; // Maximum number of tiles
var minDamage = 10; // Minimum damage
var maxDamage = 15; // Maximum damage
var backgroundContainer = new BackgroundContainer();
game.addChild(backgroundContainer);
var midgroundContainer = new MidgroundContainer();
game.addChild(midgroundContainer);
var foregroundContainer = new ForegroundContainer();
game.addChild(foregroundContainer);
var wheel = new SpinningWheel();
midgroundContainer.addChild(wheel);
wheel.init();
wheel.x = 150; // Initial x position
wheel.y = 2500; // Space cells horizontally
game.addChild(wheel);
// Initialize the Peon and add it to the game
var peon = new Peon();
peon.init(wheel);
game.addChild(peon);
// Function to create a new enemy
function createNewEnemy() {
	// Define available enemy types and their HP increments
	var enemyTypes = [{
		asset: 'enemy',
		hpIncrement: 0
	}, {
		asset: 'enemy_2',
		hpIncrement: -10
	}, {
		asset: 'enemy_3',
		hpIncrement: 10
	}];
	// Select a random enemy type
	var randomIndex = Math.floor(Math.random() * enemyTypes.length);
	var selectedEnemy = enemyTypes[randomIndex];
	// Instantiate the enemy with required parameters
	var newEnemy = new Enemy(selectedEnemy.asset, selectedEnemy.hpIncrement);
	game.addChild(newEnemy);
	return newEnemy;
}
// Initialize the first enemy
var enemy = createNewEnemy();
// Add a text to display the player's HP
// Add a down event to the game to spin the Peon when the screen is tapped
game.down = function (x, y, obj) {
	if (gameState !== "upgradeMode" && !wheel.isSpinning) {
		wheel.spin(peon);
	}
};

===================================================================
--- original.js
+++ change.js
@@ -470,8 +470,10 @@
 				anchorY: 0.5,
 				x: i * 250 // Increase space between cells
 			});
 			self.addChild(cellDisplay);
+			// Link the display object to the data object
+			self.cells[i].display = cellDisplay;
 			// Add text to each cell to display the damage value
 			var damageText = new Text2(self.cells[i].damage.toString(), {
 				size: 50,
 				fill: 0xFFFFFF