/**** 
* 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 () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.init = function () {
		self.x = 2048 / 2;
		self.y = 2732 / 2 - 500;
		// Initialize the enemy's HP
		if (typeof this.constructor.hp === 'undefined') {
			this.constructor.hp = 100;
		} else {
			this.constructor.hp += enemyHpIncrement;
		}
		self.hp = this.constructor.hp;
		// 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
		self.hpText.setText("HP: " + self.hp);
	};
});
var Enemy2 = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy_2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.init = function () {
		self.x = 2048 / 2;
		self.y = 2732 / 2 - 500;
		if (typeof this.constructor.hp === 'undefined') {
			this.constructor.hp = 100;
		} else {
			this.constructor.hp += enemyHpIncrement * 0.5;
		}
		self.hp = this.constructor.hp;
		self.hpText = new Text2("", {
			size: 200,
			fill: 0xFFFFFF
		});
		self.hpText.anchor.set(0.5, 0.5);
		self.hpText.y = -700;
		self.addChild(self.hpText);
		self.hpText.setText("HP: " + self.hp);
	};
});
var Enemy3 = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy_3', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.init = function () {
		self.x = 2048 / 2;
		self.y = 2732 / 2 - 500;
		if (typeof this.constructor.hp === 'undefined') {
			this.constructor.hp = 100;
		} else {
			this.constructor.hp += enemyHpIncrement * 1.5;
		}
		self.hp = this.constructor.hp;
		self.hpText = new Text2("", {
			size: 200,
			fill: 0xFFFFFF
		});
		self.hpText.anchor.set(0.5, 0.5);
		self.hpText.y = -700;
		self.addChild(self.hpText);
		self.hpText.setText("HP: " + self.hp);
	};
});
// 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.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
		var 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;
			}
			steps--;
			currentInterval *= multiplier; // Increase the interval by the multiplier
			if (steps <= 0) {
				// Peon lands on the final cell
				self.x = wheel.x + self.currentPosition * 250;
				// Extract the damage value from the landed cell
				var damage = wheel.cells[self.currentPosition].damage;
				if (wheel.cells[self.currentPosition].actionType === 'heal') {
					console.log("Landed on a healing cell. No damage inflicted.");
					damage = 0;
				} else {
					console.log("Damage for next attack: " + damage);
				}
				// Create a new projectile and shoot it towards the enemy
				var projectile = new Projectile();
				projectile.init(self.x, self.y, enemy.x, enemy.y, 10, damage);
				game.addChild(projectile);
				wheel.isSpinning = false; // Set isSpinning to false after the spin is complete
				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;
	};
	// Move the Projectile towards its target
	self.update = function () {
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist < self.speed) {
			self.x = self.targetX;
			self.y = self.targetY;
		} 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;
				// Update the enemy's HP text
				enemy.hpText.setText("HP: " + enemy.hp);
				// Destroy the projectile
				self.destroy();
				// 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();
					// Pause the game
					LK.showGameOver();
					// Offer choices to the player
					var choice = prompt("Choose an upgrade:\n1. +5 Damage to all cells\n2. +10 to Small Damage tiles\n3. +25 to Big Damage tiles\n4. +100 to Critical Damage tiles");
					switch (choice) {
						case '1':
							for (var i = 0; i < wheel.cells.length; i++) {
								wheel.cells[i].damage += 5;
							}
							break;
						case '2':
							for (var i = 0; i < wheel.cells.length; i++) {
								if (wheel.cells[i].damage === 10) {
									wheel.cells[i].damage += 10;
								}
							}
							break;
						case '3':
							for (var i = 0; i < wheel.cells.length; i++) {
								if (wheel.cells[i].damage === 25) {
									wheel.cells[i].damage += 25;
								}
							}
							break;
						case '4':
							for (var i = 0; i < wheel.cells.length; i++) {
								if (wheel.cells[i].damage === 100) {
									wheel.cells[i].damage += 100;
								}
							}
							break;
						default:
							alert("Invalid choice. No upgrade applied.");
					}
					// Unpause the game
					LK.showGameOver();
					// Create a custom explosion animation
					var explosion = self.attachAsset('enemy', {
						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 = new Enemy();
					enemy.init();
					enemy.hpText.setText("HP: " + enemy.hp); // Update the enemy's HP text
					game.addChild(enemy);
				}
			}
		}
	};
});
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: 0,
			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
			});
			midgroundContainer.addChild(cell);
			// Add text to each cell to display the damage value
			var damageLabel = '';
			switch (self.cells[i].damage) {
				case 10:
					damageLabel = 'Minor Damage';
					break;
				case 25:
					damageLabel = 'Major Damage';
					break;
				case 100:
					damageLabel = 'Critical Damage';
					break;
				default:
					damageLabel = 'Unknown';
			}
			var damageText = new Text2(self.cells[i].damage.toString(), {
				size: 50,
				fill: 0xFFFFFF
			});
			damageText.anchor.set(0.5, 0.5);
			damageText.x = cell.x; // Center text on the tile
			damageText.y = cell.y; // Center text on the tile
			foregroundContainer.addChild(damageText);
			// Add a label to each cell to indicate the damage type
			var damageLabel = '';
			switch (self.cells[i].damage) {
				case 10:
					damageLabel = 'Minor Damage';
					break;
				case 25:
					if (self.cells[i].actionType === 'heal') {
						damageLabel = 'Major Heal';
					} else {
						damageLabel = 'Major Damage';
					}
					break;
				case 100:
					damageLabel = 'Critical Damage';
					break;
				default:
					damageLabel = 'Unknown';
			}
			var label = new Text2(damageLabel, {
				size: 30,
				fill: 0xAAAAAA
			});
			label.anchor.set(0.5, 1.5); // Position label below the damage value
			foregroundContainer.addChild(label);
		}
	};
	// Spin the Peon around the wheel
	self.spin = function (peon) {
		if (!self.isSpinning) {
			self.isSpinning = true;
			peon.spin(self);
		}
	};
});

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

/**** 
* Game Code
****/ 
// Initialize spinning wheel
// Global timing variables
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 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);
var enemyHpIncrement = 50;
var enemyClasses = [Enemy, Enemy2, Enemy3];
var randomIndex = Math.floor(Math.random() * enemyClasses.length);
var enemy = new enemyClasses[randomIndex]();
enemy.init();
game.addChild(enemy);
// 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
@@ -322,8 +322,10 @@
 				size: 50,
 				fill: 0xFFFFFF
 			});
 			damageText.anchor.set(0.5, 0.5);
+			damageText.x = cell.x; // Center text on the tile
+			damageText.y = cell.y; // Center text on the tile
 			foregroundContainer.addChild(damageText);
 			// Add a label to each cell to indicate the damage type
 			var damageLabel = '';
 			switch (self.cells[i].damage) {