/**** 
* 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>
// SpinningWheel class to represent the spinning wheel mechanic
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 = 100 + 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);
});
// Current interval for the spin
// Peon class to represent the player's element
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; // 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 Peon on the random cell
	};
	// Spin the Peon around the wheel
	self.spin = function (wheel) {
		// Generate a random integer between 10 and 15
		self.steps = Math.floor(Math.random() * 6) + 11;
		var _spinStep = function spinStep() {
			self.currentPosition = (self.currentPosition + 1) % 8; // Update Peon's current position
			self.x = wheel.x + self.currentPosition * 250; // Move Peon one cell to the right
			if (self.currentPosition == 0) {
				// If Peon 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) {
				// Peon 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 peon 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();
					// 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
	};
});
// ProjectilePool class to manage projectile instances
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 = [{
			damage: 10,
			actionType: 'damage'
		}, {
			damage: 25,
			actionType: 'damage'
		}, {
			damage: 10,
			actionType: 'damage'
		}, {
			damage: 100,
			actionType: 'damage'
		}, {
			damage: 10,
			actionType: 'damage'
		}, {
			damage: 25,
			actionType: 'damage'
		}, {
			damage: 10,
			actionType: 'damage'
		}, {
			damage: 50,
			actionType: 'heal'
		}];
		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 Peon around the wheel
	self.spin = function (peon) {
		if (!self.isSpinning) {
			self.isSpinning = true;
			peon.spin(self);
			// Deduct damage from player's HP after peon stops
		}
	};
});

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

/**** 
* Game Code
****/ 
// Helper function to calculate distance between two points
// Cache enemy assets for reuse
// ProjectilePool class to manage projectile instances
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 = 15; // Starting interval for the spin
var multiplier = 1.2; // Multiplier for the interval increase
var currentInterval = startingInterval;
var startingMovingTiles = 7; // Starting moving tiles
var maxTiles = 25; // 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: -50
	}, {
		asset: 'enemy_3',
		hpIncrement: 100
	}];
	// 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 (!wheel.isSpinning) {
		wheel.spin(peon);
	}
};

===================================================================
--- original.js
+++ change.js
@@ -80,14 +80,13 @@
 		// Generate a random integer between 10 and 15
 		self.steps = Math.floor(Math.random() * 6) + 11;
 		var _spinStep = function spinStep() {
 			self.currentPosition = (self.currentPosition + 1) % 8; // Update Peon's current position
-			tween(self, {
-				x: wheel.x + self.currentPosition * 250
-			}, {
-				duration: currentInterval,
-				easing: tween.easeOut
-			});
+			self.x = wheel.x + self.currentPosition * 250; // Move Peon one cell to the right
+			if (self.currentPosition == 0) {
+				// If Peon 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) {
 				// Peon lands on the final cell
@@ -145,19 +144,9 @@
 				};
 				_deductHp();
 				currentInterval = startingInterval; // Reset the interval to the starting interval
 			} else {
-				// Schedule the next step using a game loop
-				var updateObject = new Container();
-				updateObject.update = function () {
-					if (currentInterval <= 0) {
-						_spinStep();
-						game.removeChild(updateObject);
-					} else {
-						currentInterval--;
-					}
-				};
-				game.addChild(updateObject);
+				LK.setTimeout(_spinStep, currentInterval); // Schedule the next step
 			}
 		};
 		_spinStep(); // Start the spin
 	};
@@ -186,9 +175,9 @@
 			return;
 		} // Skip update if not active
 		var dx = self.targetX - self.x;
 		var dy = self.targetY - self.y;
-		var dist = Math.sqrt(dx * dx + dy * dy);
+		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
@@ -281,19 +270,9 @@
 							explosion.alpha -= 0.05;
 							if (explosion.alpha <= 0) {
 								explosion.destroy();
 							} else {
-								// Schedule the fade out using a game loop
-								game.addChild({
-									update: function update() {
-										if (explosion.alpha <= 0) {
-											explosion.destroy();
-											game.removeChild(this);
-										} else {
-											explosion.alpha -= 0.05;
-										}
-									}
-								});
+								LK.setTimeout(_fadeOut, 50);
 							}
 						};
 						_fadeOut();
 					}
@@ -388,10 +367,14 @@
 
 /**** 
 * Game Code
 ****/ 
-// 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
+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', {})
@@ -433,9 +416,9 @@
 		return newProjectile;
 	};
 };
 var startingInterval = 15; // Starting interval for the spin
-var multiplier = 1.05; // Multiplier for the interval increase
+var multiplier = 1.2; // Multiplier for the interval increase
 var currentInterval = startingInterval;
 var startingMovingTiles = 7; // Starting moving tiles
 var maxTiles = 25; // Maximum number of tiles
 var minDamage = 10; // Minimum damage