/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
var AIPlayer = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('ai', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.row = -1; // AI starts above the bridge
	self.col = 3; // Center column of 7-column grid
	self.isAI = true;
	self.moveTo = function (newRow, newCol) {
		self.row = newRow;
		self.col = newCol;
		var targetX = gameStartX + newCol * CELL_SIZE;
		var targetY = gameStartY + newRow * CELL_SIZE;
		tween(self, {
			x: targetX,
			y: targetY
		}, {
			duration: 300
		});
		LK.getSound('move').play();
	};
	return self;
});
var CharacterSelectionButton = Container.expand(function (characterType, x, y) {
	var self = Container.call(this);
	var button = self.attachAsset('selectionButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var character = self.attachAsset(characterType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = x;
	self.y = y;
	self.characterType = characterType;
	self.selected = false;
	self.highlight = function () {
		tween(button, {
			tint: 0xFFFFAA
		}, {
			duration: 200
		});
	};
	self.unhighlight = function () {
		tween(button, {
			tint: 0xFFFFFF
		}, {
			duration: 200
		});
	};
	self.select = function () {
		self.selected = true;
		tween(button, {
			tint: 0x00FF00
		}, {
			duration: 200
		});
	};
	self.down = function (x, y, obj) {
		selectCharacter(self.characterType);
	};
	return self;
});
var GridCell = Container.expand(function () {
	var self = Container.call(this);
	var border = self.attachAsset('gridBorder', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var cell = self.attachAsset('gridCell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.isBroken = false;
	self.isRevealed = false;
	self.row = 0;
	self.col = 0;
	self.revealBroken = function () {
		if (self.isBroken && !self.isRevealed) {
			cell.visible = false;
			var brokenGraphics = self.attachAsset('brokenGlass', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			self.isRevealed = true;
			LK.getSound('break').play();
			tween(brokenGraphics, {
				alpha: 0.8
			}, {
				duration: 300
			});
		}
	};
	self.highlight = function () {
		tween(cell, {
			tint: 0xFFFFAA
		}, {
			duration: 200
		});
	};
	self.unhighlight = function () {
		tween(cell, {
			tint: 0xFFFFFF
		}, {
			duration: 200
		});
	};
	return self;
});
var Player = Container.expand(function (characterType) {
	var self = Container.call(this);
	var assetName = characterType || 'player';
	var graphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.row = 15; // Player starts below the bridge
	self.col = 3; // Center column of 7-column grid
	self.isAI = false;
	self.characterType = assetName;
	self.moveTo = function (newRow, newCol) {
		self.row = newRow;
		self.col = newCol;
		var targetX = gameStartX + newCol * CELL_SIZE;
		var targetY = gameStartY + newRow * CELL_SIZE;
		tween(self, {
			x: targetX,
			y: targetY
		}, {
			duration: 300
		});
		LK.getSound('move').play();
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x001122
});

/**** 
* Game Code
****/ 
var GRID_ROWS = 15;
var GRID_COLS = 7; // Expanded from 5 to 7 columns for wider gameplay area
var CELL_SIZE = 120; // Increased cell size for better mobile experience
var gameStartX = (2048 - GRID_COLS * CELL_SIZE) / 2 + CELL_SIZE / 2;
var totalGameHeight = CELL_SIZE + GRID_ROWS * CELL_SIZE + CELL_SIZE + 100; // AI start area + bridge + player start area + padding
var gameStartY = (2732 - totalGameHeight) / 2 + CELL_SIZE; // Center vertically and account for AI start area
var startingAreaY = gameStartY - CELL_SIZE - 50; // Starting area above bridge for AI
var endingAreaY = gameStartY + GRID_ROWS * CELL_SIZE + 50; // Starting area below bridge for player
var grid = [];
var brokenPanels = [];
var player;
var aiPlayer;
var currentTurn = 'player';
var gameOver = false;
var turnInProgress = false;
var gunDisplay; // Gun display for showing turn order
// Previous position tracking for broken glass restoration
var playerPreviousPosition = {
	row: 15,
	col: 3
}; // Player's previous position
var aiPreviousPosition = {
	row: -1,
	col: 3
}; // AI's previous position
// Character selection variables
var gameState = 'characterSelection'; // 'characterSelection' or 'playing'
var selectedCharacter = null;
var characterOptions = [];
var characterSelectionUI = [];
// Lighting variables
var leftLight;
var rightLight;
var lightingInitialized = false;
// Initialize character selection screen
function initCharacterSelection() {
	var titleText = new Text2('Choose Your Character', {
		size: 120,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.x = 2048 / 2;
	titleText.y = 400;
	game.addChild(titleText);
	characterSelectionUI.push(titleText);
	// Add shine effect to title text
	tween(titleText, {
		tint: 0xFFDD00
	}, {
		duration: 1500,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(titleText, {
				tint: 0xFFFFFF
			}, {
				duration: 1500,
				easing: tween.easeInOut
			});
		}
	});
	var characters = [{
		type: 'player',
		name: 'Green'
	}, {
		type: 'playerBlue',
		name: 'Blue'
	}, {
		type: 'playerRed',
		name: 'Red'
	}, {
		type: 'playerPurple',
		name: 'Purple'
	}];
	var startX = 2048 / 2 - (characters.length - 1) * 150;
	for (var i = 0; i < characters.length; i++) {
		var button = new CharacterSelectionButton(characters[i].type, startX + i * 300, 2732 / 2);
		game.addChild(button);
		characterOptions.push(button);
		characterSelectionUI.push(button);
		var nameText = new Text2(characters[i].name, {
			size: 60,
			fill: 0xFFFFFF
		});
		nameText.anchor.set(0.5, 0.5);
		nameText.x = button.x;
		nameText.y = button.y + 150;
		game.addChild(nameText);
		characterSelectionUI.push(nameText);
		// Add shine effect to character selection buttons
		var delay = i * 200;
		LK.setTimeout(function (btn, txt) {
			return function () {
				tween(btn, {
					tint: 0xFFDD88
				}, {
					duration: 1200,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(btn, {
							tint: 0xFFFFFF
						}, {
							duration: 1200,
							easing: tween.easeInOut
						});
					}
				});
				tween(txt, {
					tint: 0xFFDD88
				}, {
					duration: 1200,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(txt, {
							tint: 0xFFFFFF
						}, {
							duration: 1200,
							easing: tween.easeInOut
						});
					}
				});
			};
		}(button, nameText), delay);
	}
}
function selectCharacter(characterType) {
	selectedCharacter = characterType;
	// Clear character selection UI
	for (var i = 0; i < characterSelectionUI.length; i++) {
		characterSelectionUI[i].destroy();
	}
	characterSelectionUI = [];
	characterOptions = [];
	// Initialize the main game
	initMainGame();
	gameState = 'playing';
}
function initMainGame() {
	// Initialize grid
	for (var row = 0; row < GRID_ROWS; row++) {
		grid[row] = [];
		for (var col = 0; col < GRID_COLS; col++) {
			var cell = new GridCell();
			cell.row = row;
			cell.col = col;
			cell.x = gameStartX + col * CELL_SIZE;
			cell.y = gameStartY + row * CELL_SIZE;
			// Randomly assign broken panels (about 30% chance)
			if (Math.random() < 0.3) {
				cell.isBroken = true;
				brokenPanels.push({
					row: row,
					col: col
				});
			}
			grid[row][col] = cell;
			game.addChild(cell);
		}
	}
	// Create starting areas
	var aiStartArea = new GridCell();
	aiStartArea.x = gameStartX + 3 * CELL_SIZE; // Center column of 7-column grid
	aiStartArea.y = startingAreaY;
	game.addChild(aiStartArea);
	var playerStartArea = new GridCell();
	playerStartArea.x = gameStartX + 3 * CELL_SIZE; // Center column of 7-column grid
	playerStartArea.y = endingAreaY;
	game.addChild(playerStartArea);
	// Create players
	player = new Player(selectedCharacter);
	player.row = 15; // Start below the bridge
	player.x = gameStartX + player.col * CELL_SIZE;
	player.y = endingAreaY;
	game.addChild(player);
	aiPlayer = new AIPlayer();
	aiPlayer.row = -1; // Start above the bridge
	aiPlayer.x = gameStartX + aiPlayer.col * CELL_SIZE;
	aiPlayer.y = startingAreaY;
	game.addChild(aiPlayer);
	// Initialize previous positions
	playerPreviousPosition = {
		row: player.row,
		col: player.col
	};
	aiPreviousPosition = {
		row: aiPlayer.row,
		col: aiPlayer.col
	};
	// Initialize lighting system
	if (!lightingInitialized) {
		leftLight = LK.getAsset('leftLight', {
			anchorX: 1.0,
			anchorY: 0.5,
			alpha: 0.15
		});
		leftLight.x = 0;
		leftLight.y = 2732 / 2;
		game.addChild(leftLight);
		rightLight = LK.getAsset('rightLight', {
			anchorX: 0.0,
			anchorY: 0.5,
			alpha: 0.15
		});
		rightLight.x = 2048;
		rightLight.y = 2732 / 2;
		game.addChild(rightLight);
		// Start lighting animation
		animateLighting();
		lightingInitialized = true;
	}
	// Gun display for game order
	gunDisplay = LK.getAsset('gun', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	gunDisplay.x = 200; // Middle left position
	gunDisplay.y = 2732 / 2; // Vertically centered
	game.addChild(gunDisplay);
	// Start playing theme music
	LK.playMusic('themeMusic');
	// Add shine effect to all elements
	LK.setTimeout(function () {
		addShineToAllElements();
	}, 1000); // Delay to ensure all elements are properly initialized
}
// Start with character selection
initCharacterSelection();
// Gun barrel rotation to show turn order
function updateGunDirection() {
	if (!gunDisplay) return; // Don't update if gun not initialized yet
	if (currentTurn === 'player') {
		// Point gun up towards AI
		gunDisplay.rotation = -Math.PI / 2;
	} else {
		// Point gun down towards player
		gunDisplay.rotation = Math.PI / 2;
	}
}
// Initialize gun direction
updateGunDirection();
// UI Elements
var turnText = new Text2('Your Turn', {
	size: 80,
	fill: 0xFFFFFF
});
turnText.anchor.set(0.5, 0);
turnText.visible = false;
LK.gui.top.addChild(turnText);
var instructionText = new Text2('Tap adjacent cell to move', {
	size: 60,
	fill: 0xCCCCCC
});
instructionText.anchor.set(0.5, 0);
instructionText.y = 100;
instructionText.visible = false;
LK.gui.top.addChild(instructionText);
var progressText = new Text2('Progress: You 0/15 - AI 0/15', {
	size: 50,
	fill: 0xFFFFFF
});
progressText.anchor.set(0.5, 1);
LK.gui.bottom.addChild(progressText);
function updateProgressText() {
	var playerProgress = Math.max(0, 15 - player.row); // Player progress from starting position
	var aiProgress = Math.max(0, aiPlayer.row + 1); // AI progress from starting position
	progressText.setText('Progress: You ' + playerProgress + '/15 - AI ' + aiProgress + '/15');
}
function isValidMove(fromRow, fromCol, toRow, toCol) {
	// Special case: moving from starting areas onto bridge
	if (fromRow === -1 && toRow === 0) {
		// AI entering bridge from above
		return toCol >= 0 && toCol < GRID_COLS && Math.abs(toCol - fromCol) <= 1;
	}
	if (fromRow === 15 && toRow === 14) {
		// Player entering bridge from below
		return toCol >= 0 && toCol < GRID_COLS && Math.abs(toCol - fromCol) <= 1;
	}
	// Check bounds for normal bridge movement
	if (toRow < 0 || toRow >= GRID_ROWS || toCol < 0 || toCol >= GRID_COLS) {
		return false;
	}
	// Check if adjacent (including diagonal)
	var rowDiff = Math.abs(toRow - fromRow);
	var colDiff = Math.abs(toCol - fromCol);
	if (rowDiff > 1 || colDiff > 1 || rowDiff === 0 && colDiff === 0) {
		return false;
	}
	return true;
}
// Calculate optimal path for player (moving up to reach top)
function calculatePlayerPath(startRow, startCol, targetRow) {
	var openSet = [{
		row: startRow,
		col: startCol,
		gScore: 0,
		fScore: Math.abs(startRow - targetRow),
		parent: null
	}];
	var closedSet = [];
	var visited = {};
	while (openSet.length > 0) {
		// Find node with lowest fScore
		var current = openSet[0];
		var currentIndex = 0;
		for (var i = 1; i < openSet.length; i++) {
			if (openSet[i].fScore < current.fScore) {
				current = openSet[i];
				currentIndex = i;
			}
		}
		// Remove current from openSet
		openSet.splice(currentIndex, 1);
		// Add to closed set
		var key = current.row + ',' + current.col;
		closedSet.push(current);
		visited[key] = true;
		// Check if we reached target row
		if (current.row <= targetRow) {
			// Reconstruct path
			var path = [];
			var node = current;
			while (node !== null) {
				path.unshift({
					row: node.row,
					col: node.col
				});
				node = node.parent;
			}
			return path;
		}
		// Explore neighbors
		for (var dRow = -1; dRow <= 1; dRow++) {
			for (var dCol = -1; dCol <= 1; dCol++) {
				if (dRow === 0 && dCol === 0) continue;
				var newRow = current.row + dRow;
				var newCol = current.col + dCol;
				var neighborKey = newRow + ',' + newCol;
				// Skip if already visited or invalid move
				if (visited[neighborKey] || !isValidMove(current.row, current.col, newRow, newCol)) {
					continue;
				}
				// Skip if we know it's broken glass
				if (newRow >= 0 && newRow < GRID_ROWS && grid[newRow] && grid[newRow][newCol] && grid[newRow][newCol].isRevealed && grid[newRow][newCol].isBroken) {
					continue;
				}
				// Calculate scores
				var gScore = current.gScore + 1;
				// Add penalty for potentially broken glass (unexplored cells)
				var heuristic = Math.abs(newRow - targetRow) + Math.abs(3 - newCol); // Prefer center column
				if (newRow >= 0 && newRow < GRID_ROWS && grid[newRow] && grid[newRow][newCol] && !grid[newRow][newCol].isRevealed) {
					heuristic += 1; // Small penalty for unknown cells
				}
				var fScore = gScore + heuristic;
				// Check if this path to neighbor is better
				var existingNode = null;
				for (var j = 0; j < openSet.length; j++) {
					if (openSet[j].row === newRow && openSet[j].col === newCol) {
						existingNode = openSet[j];
						break;
					}
				}
				if (existingNode === null || gScore < existingNode.gScore) {
					var neighbor = {
						row: newRow,
						col: newCol,
						gScore: gScore,
						fScore: fScore,
						parent: current
					};
					if (existingNode === null) {
						openSet.push(neighbor);
					} else {
						existingNode.gScore = gScore;
						existingNode.fScore = fScore;
						existingNode.parent = current;
					}
				}
			}
		}
	}
	return null; // No path found
}
function highlightValidMoves(currentPlayer) {
	// Check if grid is initialized
	if (!grid || grid.length === 0) return;
	// Unhighlight all cells first
	for (var row = 0; row < GRID_ROWS; row++) {
		for (var col = 0; col < GRID_COLS; col++) {
			if (grid[row] && grid[row][col]) {
				grid[row][col].unhighlight();
			}
		}
	}
	// Calculate optimal path for player guidance
	var optimalPath = null;
	if (!currentPlayer.isAI) {
		optimalPath = calculatePlayerPath(currentPlayer.row, currentPlayer.col, 0);
	}
	// Highlight valid moves with path guidance
	for (var dRow = -1; dRow <= 1; dRow++) {
		for (var dCol = -1; dCol <= 1; dCol++) {
			if (dRow === 0 && dCol === 0) continue;
			var newRow = currentPlayer.row + dRow;
			var newCol = currentPlayer.col + dCol;
			if (isValidMove(currentPlayer.row, currentPlayer.col, newRow, newCol)) {
				if (grid[newRow] && grid[newRow][newCol]) {
					// Check if this move is part of optimal path
					var isOptimalMove = false;
					if (optimalPath && optimalPath.length > 1) {
						for (var p = 1; p < optimalPath.length; p++) {
							if (optimalPath[p].row === newRow && optimalPath[p].col === newCol) {
								isOptimalMove = true;
								break;
							}
						}
					}
					if (isOptimalMove) {
						// Highlight optimal moves more prominently
						tween(grid[newRow][newCol], {
							tint: 0x00FF88 // Green for optimal path
						}, {
							duration: 200
						});
					} else {
						grid[newRow][newCol].highlight();
					}
				}
			}
		}
	}
}
// AI pathfinding algorithm using A* search
function calculateAIPath(startRow, startCol, targetRow) {
	var openSet = [{
		row: startRow,
		col: startCol,
		gScore: 0,
		fScore: Math.abs(targetRow - startRow),
		parent: null
	}];
	var closedSet = [];
	var visited = {};
	while (openSet.length > 0) {
		// Find node with lowest fScore
		var current = openSet[0];
		var currentIndex = 0;
		for (var i = 1; i < openSet.length; i++) {
			if (openSet[i].fScore < current.fScore) {
				current = openSet[i];
				currentIndex = i;
			}
		}
		// Remove current from openSet
		openSet.splice(currentIndex, 1);
		// Add to closed set
		var key = current.row + ',' + current.col;
		closedSet.push(current);
		visited[key] = true;
		// Check if we reached target row
		if (current.row >= targetRow) {
			// Reconstruct path
			var path = [];
			var node = current;
			while (node !== null) {
				path.unshift({
					row: node.row,
					col: node.col
				});
				node = node.parent;
			}
			return path;
		}
		// Explore neighbors
		for (var dRow = -1; dRow <= 1; dRow++) {
			for (var dCol = -1; dCol <= 1; dCol++) {
				if (dRow === 0 && dCol === 0) continue;
				var newRow = current.row + dRow;
				var newCol = current.col + dCol;
				var neighborKey = newRow + ',' + newCol;
				// Skip if already visited or invalid move
				if (visited[neighborKey] || !isValidMove(current.row, current.col, newRow, newCol)) {
					continue;
				}
				// Skip if we know it's broken glass
				if (newRow >= 0 && newRow < GRID_ROWS && grid[newRow] && grid[newRow][newCol] && grid[newRow][newCol].isRevealed && grid[newRow][newCol].isBroken) {
					continue;
				}
				// Calculate scores
				var gScore = current.gScore + 1;
				// Add penalty for potentially broken glass (unexplored cells)
				var heuristic = Math.abs(targetRow - newRow) + Math.abs(3 - newCol); // Prefer center column
				if (newRow >= 0 && newRow < GRID_ROWS && grid[newRow] && grid[newRow][newCol] && !grid[newRow][newCol].isRevealed) {
					heuristic += 2; // Small penalty for unknown cells
				}
				var fScore = gScore + heuristic;
				// Check if this path to neighbor is better
				var existingNode = null;
				for (var j = 0; j < openSet.length; j++) {
					if (openSet[j].row === newRow && openSet[j].col === newCol) {
						existingNode = openSet[j];
						break;
					}
				}
				if (existingNode === null || gScore < existingNode.gScore) {
					var neighbor = {
						row: newRow,
						col: newCol,
						gScore: gScore,
						fScore: fScore,
						parent: current
					};
					if (existingNode === null) {
						openSet.push(neighbor);
					} else {
						existingNode.gScore = gScore;
						existingNode.fScore = fScore;
						existingNode.parent = current;
					}
				}
			}
		}
	}
	return null; // No path found
}
function makeAIMove() {
	if (gameOver || turnInProgress) return;
	var validMoves = [];
	// Find all valid moves for AI
	for (var dRow = -1; dRow <= 1; dRow++) {
		for (var dCol = -1; dCol <= 1; dCol++) {
			if (dRow === 0 && dCol === 0) continue;
			var newRow = aiPlayer.row + dRow;
			var newCol = aiPlayer.col + dCol;
			if (isValidMove(aiPlayer.row, aiPlayer.col, newRow, newCol)) {
				validMoves.push({
					row: newRow,
					col: newCol
				});
			}
		}
	}
	if (validMoves.length === 0) {
		endGame();
		return;
	}
	// Use AI pathfinding to determine best move
	var bestPath = calculateAIPath(aiPlayer.row, aiPlayer.col, 14); // Target: reach bottom of bridge
	var chosenMove;
	if (bestPath && bestPath.length > 1) {
		// Follow the calculated path
		chosenMove = bestPath[1]; // Next step in optimal path
	} else {
		// Fallback to heuristic-based strategy if no path found
		validMoves.sort(function (a, b) {
			// Prioritize avoiding known broken panels
			var aIsBroken = a.row >= 0 && a.row < GRID_ROWS && grid[a.row][a.col].isRevealed && grid[a.row][a.col].isBroken;
			var bIsBroken = b.row >= 0 && b.row < GRID_ROWS && grid[b.row][b.col].isRevealed && grid[b.row][b.col].isBroken;
			if (aIsBroken && !bIsBroken) return 1;
			if (!aIsBroken && bIsBroken) return -1;
			// Prefer moves toward center columns (safer)
			var aCenterDist = Math.abs(a.col - 3);
			var bCenterDist = Math.abs(b.col - 3);
			if (aCenterDist !== bCenterDist) return aCenterDist - bCenterDist;
			// Prefer moving down (higher row numbers)
			return b.row - a.row;
		});
		chosenMove = validMoves[0];
	}
	executeMove(aiPlayer, chosenMove.row, chosenMove.col);
}
function executeMove(currentPlayer, newRow, newCol) {
	turnInProgress = true;
	// Store current position as previous position before moving
	if (currentPlayer.isAI) {
		aiPreviousPosition = {
			row: currentPlayer.row,
			col: currentPlayer.col
		};
	} else {
		playerPreviousPosition = {
			row: currentPlayer.row,
			col: currentPlayer.col
		};
	}
	currentPlayer.moveTo(newRow, newCol);
	LK.setTimeout(function () {
		var targetCell = grid[newRow][newCol];
		if (targetCell.isBroken) {
			targetCell.revealBroken();
			// Return to previous position when stepping on broken glass
			LK.setTimeout(function () {
				if (currentPlayer.isAI) {
					currentPlayer.moveTo(aiPreviousPosition.row, aiPreviousPosition.col);
				} else {
					currentPlayer.moveTo(playerPreviousPosition.row, playerPreviousPosition.col);
				}
			}, 500); // Wait for broken glass animation to complete
		}
		updateProgressText();
		checkGameEnd();
		if (!gameOver) {
			switchTurn();
		}
		turnInProgress = false;
	}, 400);
}
function switchTurn() {
	currentTurn = currentTurn === 'player' ? 'ai' : 'player';
	updateGunDirection(); // Update gun barrel direction
	if (currentTurn === 'player') {
		turnText.setText('Your Turn');
		highlightValidMoves(player);
	} else {
		turnText.setText('AI Turn');
		// Unhighlight all cells
		for (var row = 0; row < GRID_ROWS; row++) {
			for (var col = 0; col < GRID_COLS; col++) {
				grid[row][col].unhighlight();
			}
		}
		LK.setTimeout(function () {
			makeAIMove();
		}, 1000);
	}
}
function checkGameEnd() {
	var playerProgress = Math.max(0, 15 - player.row); // Player progress from starting position
	var aiProgress = Math.max(0, aiPlayer.row + 1); // AI progress from starting position
	// Check if player reached the end (top of bridge)
	if (player.row <= 0) {
		LK.showYouWin();
		gameOver = true;
		return;
	}
	// Check if AI reached the end (bottom of bridge)
	if (aiPlayer.row >= 14) {
		LK.showGameOver();
		gameOver = true;
		return;
	}
	// Check if no valid moves available
	var playerHasMoves = false;
	var aiHasMoves = false;
	for (var dRow = -1; dRow <= 1; dRow++) {
		for (var dCol = -1; dCol <= 1; dCol++) {
			if (dRow === 0 && dCol === 0) continue;
			var playerNewRow = player.row + dRow;
			var playerNewCol = player.col + dCol;
			if (isValidMove(player.row, player.col, playerNewRow, playerNewCol)) {
				playerHasMoves = true;
			}
			var aiNewRow = aiPlayer.row + dRow;
			var aiNewCol = aiPlayer.col + dCol;
			if (isValidMove(aiPlayer.row, aiPlayer.col, aiNewRow, aiNewCol)) {
				aiHasMoves = true;
			}
		}
	}
	if (!playerHasMoves && !aiHasMoves) {
		endGame();
	}
}
function animateLighting() {
	if (!leftLight || !rightLight) return;
	// Animate left light
	tween(leftLight, {
		alpha: 0.25
	}, {
		duration: 2000,
		yoyo: true,
		repeat: -1,
		ease: 'sine'
	});
	// Animate right light with offset timing
	LK.setTimeout(function () {
		tween(rightLight, {
			alpha: 0.25
		}, {
			duration: 2000,
			yoyo: true,
			repeat: -1,
			ease: 'sine'
		});
	}, 500);
}
function addShineToAllElements() {
	// Add shine effect to all grid cells
	for (var row = 0; row < GRID_ROWS; row++) {
		for (var col = 0; col < GRID_COLS; col++) {
			if (grid[row] && grid[row][col]) {
				var delay = (row * GRID_COLS + col) * 50; // Stagger the animations
				LK.setTimeout(function (cell) {
					return function () {
						tween(cell, {
							tint: 0xFFFFAA
						}, {
							duration: 1500,
							easing: tween.easeInOut,
							onFinish: function onFinish() {
								tween(cell, {
									tint: 0xFFFFFF
								}, {
									duration: 1500,
									easing: tween.easeInOut
								});
							}
						});
					};
				}(grid[row][col]), delay);
			}
		}
	}
	// Add shine effect to players
	if (player) {
		tween(player, {
			tint: 0xFFDD88
		}, {
			duration: 2000,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(player, {
					tint: 0xFFFFFF
				}, {
					duration: 2000,
					easing: tween.easeInOut
				});
			}
		});
	}
	if (aiPlayer) {
		tween(aiPlayer, {
			tint: 0x88DDFF
		}, {
			duration: 2000,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(aiPlayer, {
					tint: 0xFFFFFF
				}, {
					duration: 2000,
					easing: tween.easeInOut
				});
			}
		});
	}
	// Add shine effect to gun display
	if (gunDisplay) {
		tween(gunDisplay, {
			tint: 0xFFCC00
		}, {
			duration: 1800,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(gunDisplay, {
					tint: 0xFFFFFF
				}, {
					duration: 1800,
					easing: tween.easeInOut
				});
			}
		});
	}
	// Add shine effect to lighting
	if (leftLight) {
		tween(leftLight, {
			tint: 0xFFFFCC
		}, {
			duration: 2500,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(leftLight, {
					tint: 0xFFFFFF
				}, {
					duration: 2500,
					easing: tween.easeInOut
				});
			}
		});
	}
	if (rightLight) {
		tween(rightLight, {
			tint: 0xFFFFCC
		}, {
			duration: 2500,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(rightLight, {
					tint: 0xFFFFFF
				}, {
					duration: 2500,
					easing: tween.easeInOut
				});
			}
		});
	}
}
function endGame() {
	gameOver = true;
	var playerProgress = Math.max(0, 15 - player.row); // Player progress from starting position 
	var aiProgress = Math.max(0, aiPlayer.row + 1); // AI progress from starting position 
	if (playerProgress > aiProgress) {
		LK.showYouWin();
	} else if (aiProgress > playerProgress) {
		LK.showGameOver();
	} else {
		LK.showGameOver(); // Tie goes to AI
	}
}
// Initialize first turn - only after main game is initialized
if (gameState === 'playing') {
	highlightValidMoves(player);
	updateProgressText();
}
game.down = function (x, y, obj) {
	if (gameState !== 'playing') return;
	if (gameOver || turnInProgress || currentTurn !== 'player') return;
	// Find which cell was clicked
	var clickedRow = Math.floor((y - gameStartY + CELL_SIZE / 2) / CELL_SIZE);
	var clickedCol = Math.floor((x - gameStartX + CELL_SIZE / 2) / CELL_SIZE);
	if (clickedRow < 0 || clickedRow >= GRID_ROWS || clickedCol < 0 || clickedCol >= GRID_COLS) {
		return;
	}
	if (isValidMove(player.row, player.col, clickedRow, clickedCol)) {
		executeMove(player, clickedRow, clickedCol);
	}
};

===================================================================
--- original.js
+++ change.js
@@ -441,8 +441,101 @@
 		return false;
 	}
 	return true;
 }
+// Calculate optimal path for player (moving up to reach top)
+function calculatePlayerPath(startRow, startCol, targetRow) {
+	var openSet = [{
+		row: startRow,
+		col: startCol,
+		gScore: 0,
+		fScore: Math.abs(startRow - targetRow),
+		parent: null
+	}];
+	var closedSet = [];
+	var visited = {};
+	while (openSet.length > 0) {
+		// Find node with lowest fScore
+		var current = openSet[0];
+		var currentIndex = 0;
+		for (var i = 1; i < openSet.length; i++) {
+			if (openSet[i].fScore < current.fScore) {
+				current = openSet[i];
+				currentIndex = i;
+			}
+		}
+		// Remove current from openSet
+		openSet.splice(currentIndex, 1);
+		// Add to closed set
+		var key = current.row + ',' + current.col;
+		closedSet.push(current);
+		visited[key] = true;
+		// Check if we reached target row
+		if (current.row <= targetRow) {
+			// Reconstruct path
+			var path = [];
+			var node = current;
+			while (node !== null) {
+				path.unshift({
+					row: node.row,
+					col: node.col
+				});
+				node = node.parent;
+			}
+			return path;
+		}
+		// Explore neighbors
+		for (var dRow = -1; dRow <= 1; dRow++) {
+			for (var dCol = -1; dCol <= 1; dCol++) {
+				if (dRow === 0 && dCol === 0) continue;
+				var newRow = current.row + dRow;
+				var newCol = current.col + dCol;
+				var neighborKey = newRow + ',' + newCol;
+				// Skip if already visited or invalid move
+				if (visited[neighborKey] || !isValidMove(current.row, current.col, newRow, newCol)) {
+					continue;
+				}
+				// Skip if we know it's broken glass
+				if (newRow >= 0 && newRow < GRID_ROWS && grid[newRow] && grid[newRow][newCol] && grid[newRow][newCol].isRevealed && grid[newRow][newCol].isBroken) {
+					continue;
+				}
+				// Calculate scores
+				var gScore = current.gScore + 1;
+				// Add penalty for potentially broken glass (unexplored cells)
+				var heuristic = Math.abs(newRow - targetRow) + Math.abs(3 - newCol); // Prefer center column
+				if (newRow >= 0 && newRow < GRID_ROWS && grid[newRow] && grid[newRow][newCol] && !grid[newRow][newCol].isRevealed) {
+					heuristic += 1; // Small penalty for unknown cells
+				}
+				var fScore = gScore + heuristic;
+				// Check if this path to neighbor is better
+				var existingNode = null;
+				for (var j = 0; j < openSet.length; j++) {
+					if (openSet[j].row === newRow && openSet[j].col === newCol) {
+						existingNode = openSet[j];
+						break;
+					}
+				}
+				if (existingNode === null || gScore < existingNode.gScore) {
+					var neighbor = {
+						row: newRow,
+						col: newCol,
+						gScore: gScore,
+						fScore: fScore,
+						parent: current
+					};
+					if (existingNode === null) {
+						openSet.push(neighbor);
+					} else {
+						existingNode.gScore = gScore;
+						existingNode.fScore = fScore;
+						existingNode.parent = current;
+					}
+				}
+			}
+		}
+	}
+	return null; // No path found
+}
 function highlightValidMoves(currentPlayer) {
 	// Check if grid is initialized
 	if (!grid || grid.length === 0) return;
 	// Unhighlight all cells first
@@ -452,22 +545,139 @@
 				grid[row][col].unhighlight();
 			}
 		}
 	}
-	// Highlight valid moves
+	// Calculate optimal path for player guidance
+	var optimalPath = null;
+	if (!currentPlayer.isAI) {
+		optimalPath = calculatePlayerPath(currentPlayer.row, currentPlayer.col, 0);
+	}
+	// Highlight valid moves with path guidance
 	for (var dRow = -1; dRow <= 1; dRow++) {
 		for (var dCol = -1; dCol <= 1; dCol++) {
 			if (dRow === 0 && dCol === 0) continue;
 			var newRow = currentPlayer.row + dRow;
 			var newCol = currentPlayer.col + dCol;
 			if (isValidMove(currentPlayer.row, currentPlayer.col, newRow, newCol)) {
 				if (grid[newRow] && grid[newRow][newCol]) {
-					grid[newRow][newCol].highlight();
+					// Check if this move is part of optimal path
+					var isOptimalMove = false;
+					if (optimalPath && optimalPath.length > 1) {
+						for (var p = 1; p < optimalPath.length; p++) {
+							if (optimalPath[p].row === newRow && optimalPath[p].col === newCol) {
+								isOptimalMove = true;
+								break;
+							}
+						}
+					}
+					if (isOptimalMove) {
+						// Highlight optimal moves more prominently
+						tween(grid[newRow][newCol], {
+							tint: 0x00FF88 // Green for optimal path
+						}, {
+							duration: 200
+						});
+					} else {
+						grid[newRow][newCol].highlight();
+					}
 				}
 			}
 		}
 	}
 }
+// AI pathfinding algorithm using A* search
+function calculateAIPath(startRow, startCol, targetRow) {
+	var openSet = [{
+		row: startRow,
+		col: startCol,
+		gScore: 0,
+		fScore: Math.abs(targetRow - startRow),
+		parent: null
+	}];
+	var closedSet = [];
+	var visited = {};
+	while (openSet.length > 0) {
+		// Find node with lowest fScore
+		var current = openSet[0];
+		var currentIndex = 0;
+		for (var i = 1; i < openSet.length; i++) {
+			if (openSet[i].fScore < current.fScore) {
+				current = openSet[i];
+				currentIndex = i;
+			}
+		}
+		// Remove current from openSet
+		openSet.splice(currentIndex, 1);
+		// Add to closed set
+		var key = current.row + ',' + current.col;
+		closedSet.push(current);
+		visited[key] = true;
+		// Check if we reached target row
+		if (current.row >= targetRow) {
+			// Reconstruct path
+			var path = [];
+			var node = current;
+			while (node !== null) {
+				path.unshift({
+					row: node.row,
+					col: node.col
+				});
+				node = node.parent;
+			}
+			return path;
+		}
+		// Explore neighbors
+		for (var dRow = -1; dRow <= 1; dRow++) {
+			for (var dCol = -1; dCol <= 1; dCol++) {
+				if (dRow === 0 && dCol === 0) continue;
+				var newRow = current.row + dRow;
+				var newCol = current.col + dCol;
+				var neighborKey = newRow + ',' + newCol;
+				// Skip if already visited or invalid move
+				if (visited[neighborKey] || !isValidMove(current.row, current.col, newRow, newCol)) {
+					continue;
+				}
+				// Skip if we know it's broken glass
+				if (newRow >= 0 && newRow < GRID_ROWS && grid[newRow] && grid[newRow][newCol] && grid[newRow][newCol].isRevealed && grid[newRow][newCol].isBroken) {
+					continue;
+				}
+				// Calculate scores
+				var gScore = current.gScore + 1;
+				// Add penalty for potentially broken glass (unexplored cells)
+				var heuristic = Math.abs(targetRow - newRow) + Math.abs(3 - newCol); // Prefer center column
+				if (newRow >= 0 && newRow < GRID_ROWS && grid[newRow] && grid[newRow][newCol] && !grid[newRow][newCol].isRevealed) {
+					heuristic += 2; // Small penalty for unknown cells
+				}
+				var fScore = gScore + heuristic;
+				// Check if this path to neighbor is better
+				var existingNode = null;
+				for (var j = 0; j < openSet.length; j++) {
+					if (openSet[j].row === newRow && openSet[j].col === newCol) {
+						existingNode = openSet[j];
+						break;
+					}
+				}
+				if (existingNode === null || gScore < existingNode.gScore) {
+					var neighbor = {
+						row: newRow,
+						col: newCol,
+						gScore: gScore,
+						fScore: fScore,
+						parent: current
+					};
+					if (existingNode === null) {
+						openSet.push(neighbor);
+					} else {
+						existingNode.gScore = gScore;
+						existingNode.fScore = fScore;
+						existingNode.parent = current;
+					}
+				}
+			}
+		}
+	}
+	return null; // No path found
+}
 function makeAIMove() {
 	if (gameOver || turnInProgress) return;
 	var validMoves = [];
 	// Find all valid moves for AI
@@ -487,17 +697,31 @@
 	if (validMoves.length === 0) {
 		endGame();
 		return;
 	}
-	// AI strategy: prioritize moving down (higher row numbers) and avoid known broken panels
-	validMoves.sort(function (a, b) {
-		var aIsBroken = grid[a.row][a.col].isRevealed && grid[a.row][a.col].isBroken;
-		var bIsBroken = grid[b.row][b.col].isRevealed && grid[b.row][b.col].isBroken;
-		if (aIsBroken && !bIsBroken) return 1;
-		if (!aIsBroken && bIsBroken) return -1;
-		return b.row - a.row; // Prefer higher row numbers (moving down)
-	});
-	var chosenMove = validMoves[0];
+	// Use AI pathfinding to determine best move
+	var bestPath = calculateAIPath(aiPlayer.row, aiPlayer.col, 14); // Target: reach bottom of bridge
+	var chosenMove;
+	if (bestPath && bestPath.length > 1) {
+		// Follow the calculated path
+		chosenMove = bestPath[1]; // Next step in optimal path
+	} else {
+		// Fallback to heuristic-based strategy if no path found
+		validMoves.sort(function (a, b) {
+			// Prioritize avoiding known broken panels
+			var aIsBroken = a.row >= 0 && a.row < GRID_ROWS && grid[a.row][a.col].isRevealed && grid[a.row][a.col].isBroken;
+			var bIsBroken = b.row >= 0 && b.row < GRID_ROWS && grid[b.row][b.col].isRevealed && grid[b.row][b.col].isBroken;
+			if (aIsBroken && !bIsBroken) return 1;
+			if (!aIsBroken && bIsBroken) return -1;
+			// Prefer moves toward center columns (safer)
+			var aCenterDist = Math.abs(a.col - 3);
+			var bCenterDist = Math.abs(b.col - 3);
+			if (aCenterDist !== bCenterDist) return aCenterDist - bCenterDist;
+			// Prefer moving down (higher row numbers)
+			return b.row - a.row;
+		});
+		chosenMove = validMoves[0];
+	}
 	executeMove(aiPlayer, chosenMove.row, chosenMove.col);
 }
 function executeMove(currentPlayer, newRow, newCol) {
 	turnInProgress = true;