/**** 
* Classes
****/
var Decision = Container.expand(function () {
	var self = Container.call(this);
	self.decide = function (callback) {
		// AI decision-making logic to choose the best cell
		// First, check if the player is about to win and block them
		// Enhanced AI decision-making process
		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);
				});
				// Additionally, check if blocking this move creates a potential win condition for AI in future turns
				var potentialWinAfterBlock = winConditions.some(function (winCondition) {
					return winCondition.includes(blockMoveIndex) && winCondition.filter(function (i) {
						return self.aiMoves.includes(i);
					}).length === 2;
				});
				if (potentialWinAfterBlock) {
					// Prioritize blocking moves that could lead to a win
					blockMoveIndex = condition.find(function (index) {
						return self.availableCells.includes(index) && winConditions.some(function (winCondition) {
							return winCondition.includes(index) && winCondition.filter(function (i) {
								return self.aiMoves.includes(i);
							}).length === 2;
						});
					});
				}
			}
		});
		// 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)];
		if (typeof callback === 'function') {
			callback(randomIndex);
		}
	};
	self.findEmptySide = function () {
		var sideIndices = [1, 3, 5, 7];
		var emptySides = sideIndices.filter(function (index) {
			return self.availableCells.includes(index);
		});
		return emptySides.length > 0 ? emptySides[Math.floor(Math.random() * emptySides.length)] : -1;
	};
	self.findOppositeCorner = function () {
		var playerCorners = [0, 2, 6, 8].filter(function (index) {
			return self.playerMoves.includes(index);
		});
		var oppositeCorners = {
			0: 8,
			2: 6,
			6: 2,
			8: 0
		};
		var availableOppositeCorners = playerCorners.map(function (index) {
			return oppositeCorners[index];
		}).filter(function (index) {
			return self.availableCells.includes(index);
		});
		return availableOppositeCorners.length > 0 ? availableOppositeCorners[0] : -1;
	};
	self.availableCells = [];
	self.playerMoves = [];
	self.aiMoves = [];
	self.observe = function (playerMoveIndex) {
		self.playerMoves.push(playerMoveIndex);
		self.availableCells.splice(self.availableCells.indexOf(playerMoveIndex), 1);
	};
	self.decide = function (callback) {
		// AI decision-making logic to choose the best cell
		// 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 (winningMoveIndex !== -1) {
					if (typeof callback === 'function') {
						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);
				});
			}
		});
		self.findTrapMove = function () {
			var trapMoveIndex = -1;
			var potentialTraps = winConditions.filter(function (condition) {
				var aiCount = condition.filter(function (index) {
					return self.aiMoves.includes(index);
				}).length;
				var availableCount = condition.filter(function (index) {
					return self.availableCells.includes(index);
				}).length;
				return aiCount === 1 && availableCount === 2;
			});
			if (potentialTraps.length >= 2) {
				var intersections = potentialTraps.reduce(function (acc, condition) {
					return acc.concat(condition.filter(function (index) {
						return self.availableCells.includes(index);
					}));
				}, []);
				var counts = intersections.reduce(function (acc, index) {
					acc[index] = (acc[index] || 0) + 1;
					return acc;
				}, {});
				var maxCount = Math.max.apply(null, Object.values(counts));
				if (maxCount === 2) {
					trapMoveIndex = parseInt(Object.keys(counts).find(function (key) {
						return counts[key] === maxCount;
					}), 10);
				}
			}
			return trapMoveIndex;
		};
		self.findForkBlock = function (playerType) {
			var moves = playerType === 'ai' ? self.aiMoves : self.playerMoves;
			var forkBlockIndex = -1;
			self.availableCells.some(function (cellIndex) {
				var forkCount = 0;
				winConditions.forEach(function (condition) {
					if (condition.includes(cellIndex)) {
						var playerCount = condition.filter(function (index) {
							return moves.includes(index);
						}).length;
						var availableCount = condition.filter(function (index) {
							return self.availableCells.includes(index) && index !== cellIndex;
						}).length;
						if (playerCount === 1 && availableCount === 1) {
							forkCount++;
							if (forkCount > 1) {
								forkBlockIndex = cellIndex;
								return true;
							}
						}
					}
				});
				if (forkCount > 1) {
					forkBlockIndex = cellIndex;
					return true;
				}
				return false;
			});
			return forkBlockIndex;
		};
		var centerIndex = 4;
		var cornerIndices = [0, 2, 6, 8];
		var oppositeCornerIndex = self.findOppositeCorner();
		var emptyCornerIndex = cornerIndices.find(function (index) {
			return self.availableCells.includes(index);
		});
		var emptySideIndex = self.findEmptySide();
		var centerIndex = 4;
		var isFirstMove = self.aiMoves.length === 0 && self.playerMoves.length === 0;
		var aiForkMoveIndex = self.findForkMove('ai');
		var playerForkMoveIndex = self.findForkMove('player');
		var isFirstMove = self.aiMoves.length === 0 && self.playerMoves.length === 0;
		var centerIndex = 4;
		var isFirstMoveCenterAvailable = isFirstMove && self.availableCells.includes(centerIndex);
		var chosenCell = winningMoveIndex !== -1 ? winningMoveIndex : blockMoveIndex !== -1 ? blockMoveIndex : aiForkMoveIndex !== -1 ? aiForkMoveIndex : playerForkMoveIndex !== -1 ? playerForkMoveIndex : isFirstMoveCenterAvailable ? centerIndex : emptyCornerIndex !== undefined ? emptyCornerIndex : oppositeCornerIndex !== -1 ? oppositeCornerIndex : emptySideIndex !== -1 ? emptySideIndex : self.availableCells.sort(function (a, b) {
			return a - b;
		})[0];
		// Execute the callback with the chosen cell index
		if (typeof callback === 'function') {
			callback(chosenCell);
		}
	};
	self.findForkMove = function (playerType) {
		var moves = playerType === 'ai' ? self.aiMoves : self.playerMoves;
		var forkMoveIndex = -1;
		self.availableCells.some(function (cellIndex) {
			var forkCount = 0;
			winConditions.forEach(function (condition) {
				if (condition.includes(cellIndex)) {
					var playerCount = condition.filter(function (index) {
						return moves.includes(index);
					}).length;
					var availableCount = condition.filter(function (index) {
						return self.availableCells.includes(index) && index !== cellIndex;
					}).length;
					if (playerCount === 1 && availableCount === 2) {
						forkCount++;
						if (forkCount > 1) {
							forkMoveIndex = cellIndex;
							return true;
						}
					}
				}
			});
			if (forkCount > 1) {
				forkMoveIndex = cellIndex;
				return true;
			}
			return false;
		});
		return forkMoveIndex;
	};
	// Initialize available cells with all cell indices
	for (var i = 0; i < 9; i++) {
		self.availableCells.push(i);
	}
	// Method to adjust AI difficulty
	self.adjustDifficulty = function (level) {
		switch (level) {
			case 1:
				// Easy
				this.predictPlayerMove = function () {
					return this.availableCells[Math.floor(Math.random() * this.availableCells.length)];
				};
				break;
			case 2:
				// Medium
				// Implement medium difficulty logic here
				break;
			case 3:
				// Hard
				// Implement hard difficulty logic here, possibly using more advanced strategies
				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) {
	var self = Container.call(this);
	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.taken && !game.aiTurn && !game.gameOver) {
			self.setPlayerValue('X');
			game.checkGameState();
			if (!game.gameOver) {
				game.aiPlayer.observePlayer(self.index);
				game.aiTurn = true;
				game.aiPlay();
			}
		}
	});
	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 () {
	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 && !game.aiCooldownActive) {
			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');
						}, 500);
						self.decision.aiMoves.push(chosenIndex);
						self.decision.availableCells.splice(self.decision.availableCells.indexOf(chosenIndex), 1);
						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;
							}
						}
					} else {
						game.aiTurn = false; // Ensure AI turn is ended if no valid move is made
					}
					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 Game
****/
var game = new LK.Game({
	backgroundColor: 0x000000 // Init game with black background
});

/**** 
* Game Code
****/
// Achievement System Class
// Define the assets for the tic tac toe game
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 _classCallCheck(instance, Constructor) {
	if (!(instance instanceof Constructor)) {
		throw new TypeError("Cannot call a class as a function");
	}
}
function _defineProperties(target, props) {
	for (var i = 0; i < props.length; i++) {
		var descriptor = props[i];
		descriptor.enumerable = descriptor.enumerable || false;
		descriptor.configurable = true;
		if ("value" in descriptor) {
			descriptor.writable = true;
		}
		Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
	}
}
function _createClass(Constructor, protoProps, staticProps) {
	if (protoProps) {
		_defineProperties(Constructor.prototype, protoProps);
	}
	if (staticProps) {
		_defineProperties(Constructor, staticProps);
	}
	Object.defineProperty(Constructor, "prototype", {
		writable: false
	});
	return Constructor;
}
function _toPropertyKey(t) {
	var i = _toPrimitive(t, "string");
	return "symbol" == _typeof(i) ? i : String(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 AchievementSystem = /*#__PURE__*/function () {
	function AchievementSystem() {
		_classCallCheck(this, AchievementSystem);
		this.achievements = [];
		// Add Beginner Achievement
		this.addAchievement('Beginner: Welcome to Tic Tac Toe!');
	}
	_createClass(AchievementSystem, [{
		key: "addAchievement",
		value: function addAchievement(description) {
			this.achievements.push(description);
			console.log('Achievement unlocked:', description);
			// Display achievement to the player
			var achievementText = new Text2('Achievement: ' + description, {
				size: 50,
				fill: "#ffffff"
			});
			achievementText.anchor.set(0.5, 0);
			achievementText.x = 2048 / 2;
			achievementText.y = 2732 - (100 + this.achievements.length * 60); // Position achievements above all cells
			LK.gui.top.addChild(achievementText);
			if (description === 'Win at Level 5') {
				console.log('Special Achievement: Master of Tic Tac Toe!');
			}
			// Add Intermediate Achievement
			if (description === 'Win 5 Games') {
				this.addAchievement('Intermediate: Tic Tac Toe Enthusiast!');
			}
			// Add Advanced Achievement
			if (description === 'Win 10 Games') {
				this.addAchievement('Advanced: Tic Tac Toe Champion!');
			}
			// Display achievement to the player
			var achievementText = new Text2('Achievement: ' + description, {
				size: 50,
				fill: "#ffffff"
			});
			achievementText.anchor.set(0.5, 0);
			achievementText.x = 2048 / 2;
			achievementText.y = 100 + this.achievements.length * 60; // Position achievements vertically
			LK.gui.top.addChild(achievementText);
		}
	}]);
	return AchievementSystem;
}(); // Initialize the Achievement System
game.achievementSystem = new AchievementSystem();
var grid = [];
// Initialize the tic tac toe grid
function initializeGrid() {
	var gridSize = 3;
	var cellSize = 400;
	var startX = (2048 - gridSize * cellSize) / 2 + cellSize / 2;
	var startY = (2732 - gridSize * cellSize) / 2 + cellSize / 2;
	for (var i = 0; i < gridSize; i++) {
		for (var j = 0; j < gridSize; j++) {
			var index = i * gridSize + j;
			var cell = new Cell(startX + j * cellSize, startY + i * cellSize, index);
			game.addChild(cell);
			grid.push(cell);
		}
	}
}
game.aiPlayer = new AIPlayer();
initializeGrid();
// Define win conditions
var winConditions = [[0, 1, 2], [3, 4, 5], [6, 7, 8],
// Rows
[0, 3, 6], [1, 4, 7], [2, 5, 8],
// Columns
[0, 4, 8], [2, 4, 6] // Diagonals
];
// Define game logic
game.level = 1; // Initialize game level
var levelCounter = new Text2('Level: ' + game.level, {
	size: 50,
	fill: "#ffffff"
});
levelCounter.anchor.set(0.5, 0);
levelCounter.x = 2048 / 2;
levelCounter.y = 50;
LK.gui.top.addChild(levelCounter);
game.aiTurn = false;
game.aiCooldown = 500; // Cooldown time in milliseconds
game.gameOver = false;
game.checkGameState = function () {
	// Check for win conditions
	var winConditions = [[0, 1, 2], [3, 4, 5], [6, 7, 8],
	// Rows
	[0, 3, 6], [1, 4, 7], [2, 5, 8],
	// Columns
	[0, 4, 8], [2, 4, 6] // Diagonals
	];
	for (var i = 0; i < winConditions.length; i++) {
		var condition = winConditions[i];
		if (grid[condition[0]].value && grid[condition[0]].value === grid[condition[1]].value && grid[condition[0]].value === grid[condition[2]].value) {
			game.gameOver = true;
			for (var i = 0; i < 3; i++) {
				LK.setTimeout(function () {
					LK.effects.flashScreen(0x00FF00, 300);
				}, i * 600);
			}
			var winner = grid[condition[0]].value === 'X' ? 'You Win!' : 'AI Wins!';
			var winText = new Text2(winner, {
				size: 150,
				fill: "#ffffff"
			});
			winText.anchor.set(0.5, 0.5);
			winText.x = 2048 / 2;
			winText.y = 2732 / 2;
			LK.gui.center.addChild(winText);
			if (grid[condition[0]].value === 'O') {
				for (var i = 0; i < 3; i++) {
					LK.setTimeout(function () {
						LK.effects.flashScreen(0xFF0000, 300);
					}, i * 600);
				}
				LK.setTimeout(function () {
					LK.showGameOver();
					game.level = 1; // Reset level to 1
					levelCounter.setText('Level: ' + game.level);
				}, 1800);
			} else {
				LK.setTimeout(function () {
					grid.forEach(function (cell) {
						cell.destroy();
					});
					grid = [];
					game.aiPlayer.decision = new Decision(); // Reset AI decision state
					game.aiTurn = false; // Reset AI turn state
					game.gameOver = false; // Reset game over state
					initializeGrid();
					grid.forEach(function (cell) {
						cell.interactive = true; // Re-enable player input
					});
					game.level++; // Increase the level
					levelCounter.setText('Level: ' + game.level);
				}, 2000);
			}
			return;
		}
	}
	// Check for draw
	var draw = grid.every(function (cell) {
		return cell.taken;
	});
	if (draw) {
		game.gameOver = true;
		var flashCount = 0;
		var flashInterval = LK.setInterval(function () {
			LK.effects.flashScreen(0xA52A2A, 300);
			flashCount++;
			if (flashCount >= 4) {
				LK.clearInterval(flashInterval);
				grid.forEach(function (cell) {
					cell.destroy();
				});
				grid = [];
				game.aiPlayer.decision = new Decision();
				game.aiTurn = false; // Reset AI turn state
				game.gameOver = false; // Reset game over state
				initializeGrid();
			}
		}, 600);
	}
};
game.aiPlay = function () {
	if (game.aiTurn) {
		LK.setTimeout(function () {
			game.aiPlayer.makeMove();
		}, game.aiCooldown);
	}
};
// Start the game with the player's turn
game.aiTurn = false;

===================================================================
--- original.js
+++ change.js
@@ -469,8 +469,10 @@
 var AchievementSystem = /*#__PURE__*/function () {
 	function AchievementSystem() {
 		_classCallCheck(this, AchievementSystem);
 		this.achievements = [];
+		// Add Beginner Achievement
+		this.addAchievement('Beginner: Welcome to Tic Tac Toe!');
 	}
 	_createClass(AchievementSystem, [{
 		key: "addAchievement",
 		value: function addAchievement(description) {
@@ -487,8 +489,16 @@
 			LK.gui.top.addChild(achievementText);
 			if (description === 'Win at Level 5') {
 				console.log('Special Achievement: Master of Tic Tac Toe!');
 			}
+			// Add Intermediate Achievement
+			if (description === 'Win 5 Games') {
+				this.addAchievement('Intermediate: Tic Tac Toe Enthusiast!');
+			}
+			// Add Advanced Achievement
+			if (description === 'Win 10 Games') {
+				this.addAchievement('Advanced: Tic Tac Toe Champion!');
+			}
 			// Display achievement to the player
 			var achievementText = new Text2('Achievement: ' + description, {
 				size: 50,
 				fill: "#ffffff"