/**** 
* 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);
					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);
					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) {
		self.x = startX;
		self.y = startY;
		self.targetX = targetX;
		self.targetY = targetY;
		self.speed = speed * 3; // Increase the bullet speed
		self.damage = damage;
		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 = [CELL_ACTIONS.DAMAGE_10, CELL_ACTIONS.DAMAGE_25, CELL_ACTIONS.DAMAGE_10, CELL_ACTIONS.DAMAGE_100, CELL_ACTIONS.DAMAGE_10, CELL_ACTIONS.DAMAGE_25, CELL_ACTIONS.DAMAGE_10, CELL_ACTIONS.HEAL_50];
		for (var i = 0; i < self.cells.length; i++) {
			var cell = self.attachAsset('tile', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: i * 250 // Increase space between cells
			});
			self.addChild(cell);
			// Add text to each cell to display the damage value
			var damageText = new Text2(self.cells[i].damage.toString(), {
				size: 50,
				fill: 0xFFFFFF
			});
			damageText.anchor.set(0.5, 0.5);
			cell.addChild(damageText);
		}
	};
	// 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 () {
	var self = Container.call(this);
	self.availableUpgrades = upgradeOptions;
	self.generateUpgradeOptions = function () {
		return getRandomUpgrades();
	};
	self.applyUpgrade = function (selectedUpgrade, target) {
		switch (selectedUpgrade.type) {
			case 'increaseDamage':
				if (target && typeof target.damage !== 'undefined') {
					target.damage += selectedUpgrade.value;
				} else {
					console.error('Target is undefined or does not have a damage property');
				}
				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.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.interactive = true;
		self.interactiveChildren = true;
		self.hitArea = new Rectangle(0, 0, 2048, 2732);
		self.on('pointerdown', function () {
			console.log('Upgrade UI clicked');
		});
		self.displayOptions();
	};
	// Display the upgrade options
	self.displayOptions = function () {
		for (var i = 0; i < 2; i++) {
			// Limit to 2 options
			var optionText = new Text2(self.upgradeOptions[i].description, {
				size: 100,
				fill: 0xFFFFFF
			});
			optionText.anchor.set(0.5, 0.5);
			optionText.x = 1024; // Center horizontally
			optionText.y = 1700 + i * 200; // Move options 700 pixels lower
			self.addChild(optionText);
			// Add interaction to select an upgrade
			optionText.interactive = true;
			optionText.pointerEnabled = true; // Enable pointer events
			optionText.hitArea = new LK.Rectangle(-optionText.width / 2, -optionText.height / 2, optionText.width, optionText.height); // Set hit area
			optionText.on('pointerdown', function (selectedUpgrade) {
				return function () {
					console.log("Option clicked");
					console.log("Upgrade option selected:", selectedUpgrade.description);
					self.selectUpgrade(selectedUpgrade);
				};
			}(self.upgradeOptions[i]));
		}
	};
	// Handle upgrade selection
	self.selectUpgrade = function (selectedUpgrade) {
		upgradeManager.applyUpgrade(selectedUpgrade, peon);
		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 
});

/**** 
* Game Code
****/ 
// 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();
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
}
// 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, peon);
// 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 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];
			}
		}
		var newProjectile = new Projectile();
		this.pool.push(newProjectile);
		return newProjectile;
	};
};
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
@@ -499,11 +499,12 @@
 			self.addChild(optionText);
 			// Add interaction to select an upgrade
 			optionText.interactive = true;
 			optionText.pointerEnabled = true; // Enable pointer events
-			optionText.hitArea = new Rectangle(-optionText.width / 2, -optionText.height / 2, optionText.width, optionText.height); // Set hit area
-			optionText.on('down', function (selectedUpgrade) {
+			optionText.hitArea = new LK.Rectangle(-optionText.width / 2, -optionText.height / 2, optionText.width, optionText.height); // Set hit area
+			optionText.on('pointerdown', function (selectedUpgrade) {
 				return function () {
+					console.log("Option clicked");
 					console.log("Upgrade option selected:", selectedUpgrade.description);
 					self.selectUpgrade(selectedUpgrade);
 				};
 			}(self.upgradeOptions[i]));