===================================================================
--- original.js
+++ change.js
@@ -1,44 +1,161 @@
 /**** 
 * Classes
 ****/
-// Define the Star class for the dynamic background
-var Star = Container.expand(function () {
+var AIPlayer = Container.expand(function () {
 	var self = Container.call(this);
-	var starGraphics = self.attachAsset('starShape', {
-		anchorX: 0.5,
-		anchorY: 0.5
-	});
-	self.speed = Math.random() * 2 + 1; // Random speed for each star
-	self.move = function () {
-		self.y += self.speed;
-		if (self.y > 2732) {
-			// Reset star position when it goes off-screen
-			self.y = -50;
-			self.x = Math.random() * 2048;
+	self.decision = new Decision();
+	self.observePlayer = function (playerMoveIndex) {
+		// AI logic to observe player's move and decide next move
+		self.decision.playerMoves.push(playerMoveIndex);
+		self.decision.availableCells.splice(self.decision.availableCells.indexOf(playerMoveIndex), 1);
+	};
+	self.makeMove = function () {
+		// Use the Decision class to choose the best cell for the AI's move
+		if (!game.gameOver && !game.aiCooldownActive) {
+			LK.setTimeout(function () {
+				// Disable player input
+				grid.forEach(function (cell) {
+					cell.interactive = false;
+				});
+				// Add a slight delay before making the AI move visible and interactive to ensure AI has "reserved" the cell
+				LK.setTimeout(function () {
+					self.decision.decide(function (chosenIndex) {
+						if (chosenIndex !== undefined && !grid[chosenIndex].taken) {
+							var indicatorShape = grid[chosenIndex].attachAsset('indicator', {
+								anchorX: 0.5,
+								anchorY: 0.5
+							});
+							LK.setTimeout(function () {
+								indicatorShape.destroy();
+								grid[chosenIndex].setPlayerValue('O');
+								self.decision.aiMoves.push(chosenIndex);
+								self.decision.availableCells.splice(self.decision.availableCells.indexOf(chosenIndex), 1);
+								game.checkGameState();
+								if (!game.gameOver) {
+									game.aiTurn = false;
+								} else {
+									self.decision.playerMoves = [];
+									self.decision.aiMoves = [];
+									for (var i = 0; i < 9; i++) {
+										self.decision.availableCells[i] = i;
+									}
+								}
+							}, 500);
+						} else {
+							game.aiTurn = false; // Ensure AI turn is ended if no valid move is made
+						}
+						// Enable player input
+						grid.forEach(function (cell) {
+							if (!cell.taken) {
+								cell.interactive = true;
+							}
+						});
+						game.aiTurn = false;
+						game.checkGameState();
+						if (game.gameOver) {
+							self.decision.playerMoves = [];
+							self.decision.aiMoves = [];
+							for (var i = 0; i < 9; i++) {
+								self.decision.availableCells[i] = i;
+							}
+						}
+					});
+				}, game.aiCooldown);
+				self.decision.decide(function (chosenIndex) {
+					if (chosenIndex !== undefined && !grid[chosenIndex].taken) {
+						var indicatorShape = grid[chosenIndex].attachAsset('indicator', {
+							anchorX: 0.5,
+							anchorY: 0.5
+						});
+						LK.setTimeout(function () {
+							indicatorShape.destroy();
+							grid[chosenIndex].setPlayerValue('O');
+							self.decision.aiMoves.push(chosenIndex);
+							self.decision.availableCells.splice(self.decision.availableCells.indexOf(chosenIndex), 1);
+							game.checkGameState();
+							if (!game.gameOver) {
+								game.aiTurn = false;
+							} else {
+								self.decision.playerMoves = [];
+								self.decision.aiMoves = [];
+								for (var i = 0; i < 9; i++) {
+									self.decision.availableCells[i] = i;
+								}
+							}
+						}, 500);
+					} else {
+						game.aiTurn = false; // Ensure AI turn is ended if no valid move is made
+					}
+					// Enable player input
+					grid.forEach(function (cell) {
+						if (!cell.taken) {
+							cell.interactive = true;
+						}
+					});
+					game.aiTurn = false;
+					game.checkGameState();
+					if (game.gameOver) {
+						self.decision.playerMoves = [];
+						self.decision.aiMoves = [];
+						for (var i = 0; i < 9; i++) {
+							self.decision.availableCells[i] = i;
+						}
+					}
+				});
+			}, game.aiCooldown);
+			game.aiCooldownActive = true;
+			LK.setTimeout(function () {
+				game.aiCooldownActive = false;
+			}, game.aiCooldown);
 		}
 	};
+	// Add a method to undo the last move
+	self.undoLastMove = function () {
+		if (self.decision.aiMoves.length > 0) {
+			var lastMoveIndex = self.decision.aiMoves.pop();
+			grid[lastMoveIndex].taken = false;
+			grid[lastMoveIndex].value = null;
+			grid[lastMoveIndex].removeChildren();
+			self.decision.availableCells.push(lastMoveIndex);
+		}
+	};
 });
-// Initialize star asset
-// Define the PowerUp class for special abilities on the board
-var PowerUp = Container.expand(function (x, y, type) {
+// Define the Cell class for the tic tac toe grid
+var Cell = Container.expand(function (x, y, index) {
 	var self = Container.call(this);
-	self.x = x;
-	self.y = y;
-	self.type = type; // 'extraTurn' or 'removeAIMove'
-	var powerUpGraphics = self.attachAsset(type === 'extraTurn' ? 'extraTurnShape' : 'removeAIMoveShape', {
+	self.index = index;
+	self.taken = false;
+	self.value = null;
+	var cellGraphics = self.attachAsset('cell', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
+	self.x = x;
+	self.y = y;
 	self.interactive = true;
 	self.on('down', function () {
-		if (self.type === 'extraTurn') {
-			game.playerExtraTurn = true;
-		} else if (self.type === 'removeAIMove') {
-			game.aiPlayer.undoLastMove();
+		if (!self.taken && !game.aiTurn && !game.gameOver) {
+			self.setPlayerValue('X');
+			game.checkGameState();
+			if (!game.gameOver) {
+				game.aiPlayer.observePlayer(self.index);
+				game.aiTurn = true;
+				game.aiPlay();
+			}
 		}
-		self.destroy();
 	});
+	self.setPlayerValue = function (value) {
+		self.taken = true;
+		self.value = value;
+		var shape = value === 'X' ? 'xShape' : 'oShape';
+		var color = value === 'X' ? 0xFF0000 : 0x0000FF;
+		var playerShape = self.attachAsset(shape, {
+			anchorX: 0.5,
+			anchorY: 0.5,
+			color: color
+		});
+	};
 });
 // Initialize power-up assets
 var Decision = Container.expand(function () {
 	var self = Container.call(this);
@@ -168,20 +285,32 @@
 			}).length;
 			var availableCount = condition.filter(function (index) {
 				return self.availableCells.includes(index);
 			}).length;
-			if (playerCount === 2 && availableCount === 1) {
-				// If player is about to win, find and block that move
-				blockMoveIndex = condition.find(function (index) {
+			if (aiCount === 2 && availableCount === 1) {
+				// If AI can win in the next move, prioritize that move
+				winningMoveIndex = condition.find(function (index) {
 					return self.availableCells.includes(index);
 				});
-				if (blockMoveIndex !== -1) {
+				if (winningMoveIndex !== -1) {
 					if (typeof callback === 'function') {
-						callback(blockMoveIndex);
+						callback(winningMoveIndex);
 					}
 					return;
 				}
 			}
+			if (aiCount === 2 && availableCount === 1) {
+				// If AI can win in the next move, prioritize that move
+				winningMoveIndex = condition.find(function (index) {
+					return self.availableCells.includes(index);
+				});
+				if (winningMoveIndex !== -1) {
+					if (typeof callback === 'function') {
+						callback(winningMoveIndex);
+					}
+					return;
+				}
+			}
 			if (playerCount === 2 && availableCount === 1) {
 				blockMoveIndex = condition.find(function (index) {
 					return self.availableCells.includes(index);
 				});
@@ -322,233 +451,71 @@
 				break;
 			case 4:
 				// Extreme
 				// Implement extreme difficulty logic, making the AI nearly unbeatable
+				// Implement extreme difficulty logic, making the AI nearly unbeatable
 				this.decide = function (callback) {
 					// Enhanced AI decision-making logic for extreme difficulty
-					// First, check if the player is about to win and block them
-					var winningMoveIndex = -1;
-					var blockMoveIndex = -1;
-					winConditions.forEach(function (condition) {
-						var aiCount = condition.filter(function (index) {
-							return self.aiMoves.includes(index);
-						}).length;
-						var playerCount = condition.filter(function (index) {
-							return self.playerMoves.includes(index);
-						}).length;
-						var availableCount = condition.filter(function (index) {
-							return self.availableCells.includes(index);
-						}).length;
-						if (aiCount === 2 && availableCount === 1) {
-							// If AI can win in the next move, prioritize that move
-							winningMoveIndex = condition.find(function (index) {
-								return self.availableCells.includes(index);
-							});
-						}
-						if (playerCount === 2 && availableCount === 1) {
-							// If player is about to win, find and block that move
-							blockMoveIndex = condition.find(function (index) {
-								return self.availableCells.includes(index);
-							});
-						}
-					});
-					// Prioritize AI's winning move over blocking
-					if (winningMoveIndex !== -1) {
-						if (typeof callback === 'function') {
-							callback(winningMoveIndex);
-						}
-						return;
-					}
-					// Use blocking move if no winning move is available
-					if (blockMoveIndex !== -1) {
-						if (typeof callback === 'function') {
-							callback(blockMoveIndex);
-						}
-						return;
-					}
-					// Find and execute fork opportunities for AI
-					var forkMove = self.findForkMove();
-					if (forkMove !== -1) {
-						if (typeof callback === 'function') {
-							callback(forkMove);
-						}
-						return;
-					}
-					// If no fork opportunity, proceed with strategic move
-					var strategicMove = self.findStrategicMove();
-					if (strategicMove !== -1) {
-						if (typeof callback === 'function') {
-							callback(strategicMove);
-						}
-						return;
-					}
-					// As a last resort, choose a random available cell
-					var randomIndex = self.availableCells[Math.floor(Math.random() * self.availableCells.length)];
+					// Utilize a more sophisticated algorithm to evaluate and choose the best move
+					// This could involve analyzing multiple future moves ahead (like in chess algorithms)
+					// and considering both offensive and defensive strategies based on the current state of the game.
+					// Placeholder for advanced decision-making algorithm
+					// Example placeholder logic
+					var chosenIndex = self.evaluateBestMove();
 					if (typeof callback === 'function') {
-						callback(randomIndex);
+						callback(chosenIndex);
 					}
 				};
+				// Placeholder method for evaluating the best move, to be implemented with advanced logic
+				self.evaluateBestMove = function () {
+					// Implement logic to evaluate and return the best move index
+					// This is a placeholder for the actual complex decision-making logic
+					return self.availableCells[Math.floor(Math.random() * self.availableCells.length)];
+				};
 				break;
 			default:
 				// Default to medium difficulty if an unknown level is provided
 				break;
 		}
 	};
 });
-// Define the Cell class for the tic tac toe grid
-var Cell = Container.expand(function (x, y, index) {
+// Initialize star asset
+// Define the PowerUp class for special abilities on the board
+var PowerUp = Container.expand(function (x, y, type) {
 	var self = Container.call(this);
-	self.index = index;
-	self.taken = false;
-	self.value = null;
-	var cellGraphics = self.attachAsset('cell', {
+	self.x = x;
+	self.y = y;
+	self.type = type; // 'extraTurn' or 'removeAIMove'
+	var powerUpGraphics = self.attachAsset(type === 'extraTurn' ? 'extraTurnShape' : 'removeAIMoveShape', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
-	self.x = x;
-	self.y = y;
 	self.interactive = true;
 	self.on('down', function () {
-		if (!self.taken && !game.aiTurn && !game.gameOver) {
-			self.setPlayerValue('X');
-			game.checkGameState();
-			if (!game.gameOver) {
-				game.aiPlayer.observePlayer(self.index);
-				game.aiTurn = true;
-				game.aiPlay();
-			}
+		if (self.type === 'extraTurn') {
+			game.playerExtraTurn = true;
+		} else if (self.type === 'removeAIMove') {
+			game.aiPlayer.undoLastMove();
 		}
+		self.destroy();
 	});
-	self.setPlayerValue = function (value) {
-		self.taken = true;
-		self.value = value;
-		var shape = value === 'X' ? 'xShape' : 'oShape';
-		var color = value === 'X' ? 0xFF0000 : 0x0000FF;
-		var playerShape = self.attachAsset(shape, {
-			anchorX: 0.5,
-			anchorY: 0.5,
-			color: color
-		});
-	};
 });
-var AIPlayer = Container.expand(function () {
+// Define the Star class for the dynamic background
+var Star = Container.expand(function () {
 	var self = Container.call(this);
-	self.decision = new Decision();
-	self.observePlayer = function (playerMoveIndex) {
-		// AI logic to observe player's move and decide next move
-		self.decision.playerMoves.push(playerMoveIndex);
-		self.decision.availableCells.splice(self.decision.availableCells.indexOf(playerMoveIndex), 1);
-	};
-	self.makeMove = function () {
-		// Use the Decision class to choose the best cell for the AI's move
-		if (!game.gameOver) {
-			LK.setTimeout(function () {
-				// Disable player input
-				grid.forEach(function (cell) {
-					cell.interactive = false;
-				});
-				// Add a slight delay before making the AI move visible and interactive to ensure AI has "reserved" the cell
-				LK.setTimeout(function () {
-					self.decision.decide(function (chosenIndex) {
-						if (chosenIndex !== undefined && !grid[chosenIndex].taken) {
-							var indicatorShape = grid[chosenIndex].attachAsset('indicator', {
-								anchorX: 0.5,
-								anchorY: 0.5
-							});
-							LK.setTimeout(function () {
-								indicatorShape.destroy();
-								grid[chosenIndex].setPlayerValue('O');
-								self.decision.aiMoves.push(chosenIndex);
-								self.decision.availableCells.splice(self.decision.availableCells.indexOf(chosenIndex), 1);
-								game.checkGameState();
-								if (!game.gameOver) {
-									game.aiTurn = false;
-								} else {
-									self.decision.playerMoves = [];
-									self.decision.aiMoves = [];
-									for (var i = 0; i < 9; i++) {
-										self.decision.availableCells[i] = i;
-									}
-								}
-							}, 500);
-						} else {
-							game.aiTurn = false; // Ensure AI turn is ended if no valid move is made
-						}
-						// Enable player input
-						grid.forEach(function (cell) {
-							if (!cell.taken) {
-								cell.interactive = true;
-							}
-						});
-						game.aiTurn = false;
-						game.checkGameState();
-						if (game.gameOver) {
-							self.decision.playerMoves = [];
-							self.decision.aiMoves = [];
-							for (var i = 0; i < 9; i++) {
-								self.decision.availableCells[i] = i;
-							}
-						}
-					});
-				}, game.aiCooldown);
-				self.decision.decide(function (chosenIndex) {
-					if (chosenIndex !== undefined && !grid[chosenIndex].taken) {
-						var indicatorShape = grid[chosenIndex].attachAsset('indicator', {
-							anchorX: 0.5,
-							anchorY: 0.5
-						});
-						LK.setTimeout(function () {
-							indicatorShape.destroy();
-							grid[chosenIndex].setPlayerValue('O');
-							self.decision.aiMoves.push(chosenIndex);
-							self.decision.availableCells.splice(self.decision.availableCells.indexOf(chosenIndex), 1);
-							game.checkGameState();
-							if (!game.gameOver) {
-								game.aiTurn = false;
-							} else {
-								self.decision.playerMoves = [];
-								self.decision.aiMoves = [];
-								for (var i = 0; i < 9; i++) {
-									self.decision.availableCells[i] = i;
-								}
-							}
-						}, 500);
-					} else {
-						game.aiTurn = false; // Ensure AI turn is ended if no valid move is made
-					}
-					// Enable player input
-					grid.forEach(function (cell) {
-						if (!cell.taken) {
-							cell.interactive = true;
-						}
-					});
-					game.aiTurn = false;
-					game.checkGameState();
-					if (game.gameOver) {
-						self.decision.playerMoves = [];
-						self.decision.aiMoves = [];
-						for (var i = 0; i < 9; i++) {
-							self.decision.availableCells[i] = i;
-						}
-					}
-				});
-			}, game.aiCooldown);
-			game.aiCooldownActive = true;
-			LK.setTimeout(function () {
-				game.aiCooldownActive = false;
-			}, game.aiCooldown);
+	var starGraphics = self.attachAsset('starShape', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.speed = Math.random() * 2 + 1; // Random speed for each star
+	self.move = function () {
+		self.y += self.speed;
+		if (self.y > 2732) {
+			// Reset star position when it goes off-screen
+			self.y = -50;
+			self.x = Math.random() * 2048;
 		}
 	};
-	// Add a method to undo the last move
-	self.undoLastMove = function () {
-		if (self.decision.aiMoves.length > 0) {
-			var lastMoveIndex = self.decision.aiMoves.pop();
-			grid[lastMoveIndex].taken = false;
-			grid[lastMoveIndex].value = null;
-			grid[lastMoveIndex].removeChildren();
-			self.decision.availableCells.push(lastMoveIndex);
-		}
-	};
 });
 
 /**** 
 * Initialize Game
@@ -559,10 +526,10 @@
 
 /**** 
 * Game Code
 ****/
-// Initialize power-up assets
 // Create stars for the dynamic background
+// Initialize power-up assets
 var stars = [];
 for (var i = 0; i < 100; i++) {
 	var star = new Star();
 	star.x = Math.random() * 2048;