/**** 
* 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);
	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);
	}
}
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 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;
}
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();
			}
		}
	}
	// Highlight valid moves
	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();
				}
			}
		}
	}
}
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;
	}
	// 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];
	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 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
@@ -183,8 +183,12 @@
 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,
@@ -287,8 +291,30 @@
 	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
@@ -509,12 +535,35 @@
 	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 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
+	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();