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

/**** 
* Classes
****/ 
var DraggableShip = Container.expand(function (length, id) {
	var self = Container.call(this);
	self.length = length;
	self.shipId = id;
	self.isHorizontal = true;
	self.isBeingDragged = false;
	self.isPlaced = false;
	self.shipCells = [];
	// Create visual representation of ship
	for (var i = 0; i < length; i++) {
		var shipCell = self.attachAsset('ship', {
			anchorX: 0,
			anchorY: 0
		});
		shipCell.x = i * CELL_SIZE;
		shipCell.y = 0;
		self.shipCells.push(shipCell);
	}
	self.rotate = function () {
		self.isHorizontal = !self.isHorizontal;
		for (var i = 0; i < self.shipCells.length; i++) {
			if (self.isHorizontal) {
				self.shipCells[i].x = i * CELL_SIZE;
				self.shipCells[i].y = 0;
			} else {
				self.shipCells[i].x = 0;
				self.shipCells[i].y = i * CELL_SIZE;
			}
		}
	};
	self.canBePlacedAt = function (gridX, gridY) {
		for (var i = 0; i < self.length; i++) {
			var x = self.isHorizontal ? gridX + i : gridX;
			var y = self.isHorizontal ? gridY : gridY + i;
			if (x >= GRID_SIZE || y >= GRID_SIZE || x < 0 || y < 0) {
				return false;
			}
			if (playerGrid[x][y].hasShip) {
				return false;
			}
		}
		return true;
	};
	self.placeOnGrid = function (gridX, gridY) {
		if (self.canBePlacedAt(gridX, gridY)) {
			for (var i = 0; i < self.length; i++) {
				var x = self.isHorizontal ? gridX + i : gridX;
				var y = self.isHorizontal ? gridY : gridY + i;
				playerGrid[x][y].setShip(self.shipId);
			}
			self.isPlaced = true;
			self.visible = false;
			return true;
		}
		return false;
	};
	self.down = function (x, y, obj) {
		if (gameState === 'placement') {
			if (self.isPlaced) {
				// Remove ship from grid for repositioning
				removeShipFromGrid(self);
				self.isPlaced = false;
				self.visible = true;
				placedShipsCount--;
				statusText.setText('Place remaining ships (' + (shipLengths.length - placedShipsCount) + ' left)');
				startButton.visible = false;
				// Position ship at current grid location for smooth dragging
				var currentGridX = -1,
					currentGridY = -1;
				for (var gx = 0; gx < GRID_SIZE; gx++) {
					for (var gy = 0; gy < GRID_SIZE; gy++) {
						if (playerGrid[gx][gy].shipId === self.shipId) {
							currentGridX = gx;
							currentGridY = gy;
							break;
						}
					}
					if (currentGridX !== -1) break;
				}
				if (currentGridX !== -1) {
					self.x = GRID_OFFSET_X + currentGridX * CELL_SIZE;
					self.y = PLAYER_GRID_Y + currentGridY * CELL_SIZE;
				}
			}
			self.isBeingDragged = true;
			draggedShip = self;
			tween(self, {
				alpha: 0.7
			}, {
				duration: 200
			});
		}
	};
	self.up = function (x, y, obj) {
		if (self.isBeingDragged && !self.isPlaced) {
			self.isBeingDragged = false;
			tween(self, {
				alpha: 1
			}, {
				duration: 200
			});
			// Try to place ship on grid with better snapping
			var gridX = Math.round((self.x - GRID_OFFSET_X) / CELL_SIZE);
			var gridY = Math.round((self.y - PLAYER_GRID_Y) / CELL_SIZE);
			// Snap to grid position
			var snapX = GRID_OFFSET_X + gridX * CELL_SIZE;
			var snapY = PLAYER_GRID_Y + gridY * CELL_SIZE;
			if (self.placeOnGrid(gridX, gridY)) {
				// Snap ship to exact grid position before hiding
				self.x = snapX;
				self.y = snapY;
				placedShipsCount++;
				if (placedShipsCount >= shipLengths.length) {
					statusText.setText('All ships placed! Press START GAME to begin');
					startButton.visible = true;
				} else {
					statusText.setText('Place remaining ships (' + (shipLengths.length - placedShipsCount) + ' left)');
				}
			} else {
				// Return to original position if can't place
				tween(self, {
					x: self.originalX,
					y: self.originalY
				}, {
					duration: 300,
					easing: tween.easeOut
				});
			}
		}
	};
	return self;
});
var GridCell = Container.expand(function (x, y, isPlayer) {
	var self = Container.call(this);
	self.gridX = x;
	self.gridY = y;
	self.isPlayer = isPlayer;
	self.hasShip = false;
	self.isHit = false;
	self.isMiss = false;
	self.shipId = -1;
	var cellGraphics = self.attachAsset('gridBox', {
		anchorX: 0,
		anchorY: 0
	});
	self.setShip = function (shipId) {
		self.hasShip = true;
		self.shipId = shipId;
		if (self.isPlayer) {
			cellGraphics.tint = 0x808080;
		}
	};
	self.markHit = function () {
		self.isHit = true;
		cellGraphics.tint = 0xFF0000;
	};
	self.markMiss = function (isEnemyMiss) {
		self.isMiss = true;
		if (isEnemyMiss) {
			// Enemy missed on player's grid - use orange color
			cellGraphics.tint = 0xffaa00;
		} else {
			// Player missed on enemy's grid - use light blue color  
			cellGraphics.tint = 0x87CEEB;
		}
	};
	self.markSunk = function () {
		cellGraphics.tint = 0x2F2F2F;
	};
	self.down = function (x, y, obj) {
		if (gameState === 'playing' && !self.isPlayer && !self.isHit && !self.isMiss) {
			playerShoot(self.gridX, self.gridY);
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var Ship = function Ship(length, id) {
	this.length = length;
	this.id = id;
	this.hits = 0;
	this.cells = [];
	this.isSunk = false;
	this.addCell = function (x, y) {
		this.cells.push({
			x: x,
			y: y
		});
	};
	this.hit = function () {
		this.hits++;
		if (this.hits >= this.length) {
			this.isSunk = true;
			return true;
		}
		return false;
	};
};
var GRID_SIZE = 10;
var CELL_SIZE = 80;
var GRID_OFFSET_X = 200;
var PLAYER_GRID_Y = 1200;
var AI_GRID_Y = 200;
var GRID_SPACING = 1000; // Distance between the two grids
var playerGrid = [];
var aiGrid = [];
var playerShips = [];
var aiShips = [];
var gameState = 'placement'; // 'placement', 'playing', 'gameOver'
var currentPlayer = 'player'; // 'player', 'ai'
var selectedX = -1;
var selectedY = -1;
var currentShipToPlace = 0;
var isHorizontalPlacement = true;
var shipLengths = [5, 4, 3, 3, 2];
var draggableShips = [];
var placedShipsCount = 0;
var draggedShip = null;
var playerGridContainer = new Container();
var aiGridContainer = new Container();
// UI Elements
var statusText = new Text2('Drag ships to your grid', {
	size: 60,
	fill: 0x000000
});
statusText.anchor.set(0.5, 0);
LK.gui.top.addChild(statusText);
var instructionText = new Text2('Double tap ships to rotate, drag to reposition', {
	size: 40,
	fill: 0x000000
});
instructionText.anchor.set(0.5, 0);
instructionText.y = 100;
LK.gui.top.addChild(instructionText);
var startButton = new Text2('START GAME', {
	size: 60,
	fill: 0x00FF00
});
startButton.anchor.set(0.5, 0.5);
startButton.x = 2048 / 2;
startButton.y = 2732 / 2; // Center vertically on screen
startButton.visible = false;
game.addChild(startButton);
startButton.down = function (x, y, obj) {
	if (gameState === 'placement' && placedShipsCount >= shipLengths.length) {
		gameState = 'playing';
		statusText.setText('Fire at enemy positions!');
		instructionText.setText('Tap enemy grid to shoot');
		startButton.visible = false;
		placeAIShips();
		// Show AI grid for player's turn to attack
		playerGridContainer.visible = false;
		aiGridContainer.visible = true;
	}
};
// Initialize grids
function initializeGrids() {
	// Add containers to game
	game.addChild(playerGridContainer);
	game.addChild(aiGridContainer);
	// Player grid (left side)
	for (var x = 0; x < GRID_SIZE; x++) {
		playerGrid[x] = [];
		for (var y = 0; y < GRID_SIZE; y++) {
			var cell = new GridCell(x, y, true);
			cell.x = GRID_OFFSET_X + x * CELL_SIZE;
			cell.y = PLAYER_GRID_Y + y * CELL_SIZE;
			playerGrid[x][y] = cell;
			playerGridContainer.addChild(cell);
		}
	}
	// AI grid (right side)
	for (var x = 0; x < GRID_SIZE; x++) {
		aiGrid[x] = [];
		for (var y = 0; y < GRID_SIZE; y++) {
			var cell = new GridCell(x, y, false);
			cell.x = GRID_OFFSET_X + GRID_SPACING + x * CELL_SIZE;
			cell.y = AI_GRID_Y + y * CELL_SIZE;
			aiGrid[x][y] = cell;
			aiGridContainer.addChild(cell);
		}
	}
	// Initialize grid visibility - show AI grid during player turn
	playerGridContainer.visible = false;
	aiGridContainer.visible = true;
	// Add grid labels
	var playerLabel = new Text2('Your Fleet', {
		size: 40,
		fill: 0x000000
	});
	playerLabel.anchor.set(0.5, 0.5);
	playerLabel.x = GRID_OFFSET_X + GRID_SIZE * CELL_SIZE / 2;
	playerLabel.y = PLAYER_GRID_Y - 50;
	playerGridContainer.addChild(playerLabel);
	var aiLabel = new Text2('Enemy Waters', {
		size: 40,
		fill: 0x000000
	});
	aiLabel.anchor.set(0.5, 0.5);
	aiLabel.x = GRID_OFFSET_X + GRID_SPACING + GRID_SIZE * CELL_SIZE / 2;
	aiLabel.y = AI_GRID_Y - 50;
	aiGridContainer.addChild(aiLabel);
	// Add coordinate labels for player grid
	for (var i = 0; i < GRID_SIZE; i++) {
		// Letters A-J on the left side
		var letterLabel = new Text2(String.fromCharCode(65 + i), {
			size: 20,
			fill: 0x000000
		});
		letterLabel.anchor.set(0.5, 0.5);
		letterLabel.x = GRID_OFFSET_X - 30;
		letterLabel.y = PLAYER_GRID_Y + i * CELL_SIZE + CELL_SIZE / 2;
		playerGridContainer.addChild(letterLabel);
		// Numbers 1-10 on the top
		var numberLabel = new Text2((i + 1).toString(), {
			size: 20,
			fill: 0x000000
		});
		numberLabel.anchor.set(0.5, 0.5);
		numberLabel.x = GRID_OFFSET_X + i * CELL_SIZE + CELL_SIZE / 2;
		numberLabel.y = PLAYER_GRID_Y - 60;
		playerGridContainer.addChild(numberLabel);
	}
	// Add coordinate labels for AI grid
	for (var i = 0; i < GRID_SIZE; i++) {
		// Letters A-J on the left side
		var letterLabel = new Text2(String.fromCharCode(65 + i), {
			size: 20,
			fill: 0x000000
		});
		letterLabel.anchor.set(0.5, 0.5);
		letterLabel.x = GRID_OFFSET_X + GRID_SPACING - 30;
		letterLabel.y = AI_GRID_Y + i * CELL_SIZE + CELL_SIZE / 2;
		aiGridContainer.addChild(letterLabel);
		// Numbers 1-10 on the top
		var numberLabel = new Text2((i + 1).toString(), {
			size: 20,
			fill: 0x000000
		});
		numberLabel.anchor.set(0.5, 0.5);
		numberLabel.x = GRID_OFFSET_X + GRID_SPACING + i * CELL_SIZE + CELL_SIZE / 2;
		numberLabel.y = AI_GRID_Y - 60;
		aiGridContainer.addChild(numberLabel);
	}
	// Create draggable ships
	var shipStartY = 800;
	var shipStartX = 1700; // Move ships to right side of screen
	for (var i = 0; i < shipLengths.length; i++) {
		var ship = new DraggableShip(shipLengths[i], i);
		ship.x = shipStartX;
		ship.y = shipStartY + i * 90;
		ship.originalX = ship.x;
		ship.originalY = ship.y;
		draggableShips.push(ship);
		game.addChild(ship);
	}
}
function selectCellForPlacement(x, y) {
	selectedX = x;
	selectedY = y;
	if (canPlaceShip(x, y, shipLengths[currentShipToPlace], isHorizontalPlacement, true)) {
		placeShip(x, y, shipLengths[currentShipToPlace], isHorizontalPlacement, true, currentShipToPlace);
		currentShipToPlace++;
		if (currentShipToPlace >= shipLengths.length) {
			gameState = 'playing';
			statusText.setText('Fire at enemy positions!');
			instructionText.setText('Tap enemy grid to shoot');
			placeAIShips();
		} else {
			statusText.setText('Place ship ' + (currentShipToPlace + 1) + ' (length: ' + shipLengths[currentShipToPlace] + ')');
		}
	}
}
function canPlaceShip(startX, startY, length, horizontal, isPlayer) {
	var grid = isPlayer ? playerGrid : aiGrid;
	for (var i = 0; i < length; i++) {
		var x = horizontal ? startX + i : startX;
		var y = horizontal ? startY : startY + i;
		if (x >= GRID_SIZE || y >= GRID_SIZE || x < 0 || y < 0) {
			return false;
		}
		if (grid[x][y].hasShip) {
			return false;
		}
	}
	return true;
}
function placeShip(startX, startY, length, horizontal, isPlayer, shipId) {
	var grid = isPlayer ? playerGrid : aiGrid;
	var ships = isPlayer ? playerShips : aiShips;
	var ship = new Ship(length, shipId);
	for (var i = 0; i < length; i++) {
		var x = horizontal ? startX + i : startX;
		var y = horizontal ? startY : startY + i;
		grid[x][y].setShip(shipId);
		ship.addCell(x, y);
	}
	ships.push(ship);
}
function placeAIShips() {
	for (var i = 0; i < shipLengths.length; i++) {
		var placed = false;
		var attempts = 0;
		while (!placed && attempts < 100) {
			var x = Math.floor(Math.random() * GRID_SIZE);
			var y = Math.floor(Math.random() * GRID_SIZE);
			var horizontal = Math.random() < 0.5;
			if (canPlaceShip(x, y, shipLengths[i], horizontal, false)) {
				placeShip(x, y, shipLengths[i], horizontal, false, i);
				placed = true;
			}
			attempts++;
		}
	}
}
function playerShoot(x, y) {
	if (currentPlayer !== 'player') return;
	var cell = aiGrid[x][y];
	var hit = false;
	if (cell.hasShip) {
		cell.markHit();
		hit = true;
		LK.getSound('hit').play();
		var ship = null;
		// Find the ship by ID in the aiShips array
		for (var i = 0; i < aiShips.length; i++) {
			if (aiShips[i].id === cell.shipId) {
				ship = aiShips[i];
				break;
			}
		}
		if (ship) {
			var sunk = ship.hit();
			if (sunk) {
				LK.getSound('sunk').play();
				markShipAsSunk(ship, false);
				if (checkVictory(false)) {
					gameState = 'gameOver';
					statusText.setText('Victory! You sank all enemy ships!');
					instructionText.setText('');
					LK.showYouWin();
					return;
				}
			}
		}
		statusText.setText('Hit! Fire again!');
	} else {
		cell.markMiss(false);
		LK.getSound('miss').play();
		currentPlayer = 'ai';
		statusText.setText('Miss! Enemy is thinking...');
		// Switch to player grid when AI attacks
		playerGridContainer.visible = true;
		aiGridContainer.visible = false;
		LK.setTimeout(function () {
			aiTurn();
		}, 2500);
	}
}
function aiTurn() {
	if (currentPlayer !== 'ai') return;
	var x, y;
	var attempts = 0;
	do {
		x = Math.floor(Math.random() * GRID_SIZE);
		y = Math.floor(Math.random() * GRID_SIZE);
		attempts++;
	} while ((playerGrid[x][y].isHit || playerGrid[x][y].isMiss) && attempts < 100);
	var cell = playerGrid[x][y];
	var hit = false;
	if (cell.hasShip) {
		cell.markHit();
		hit = true;
		LK.getSound('hit').play();
		var ship = null;
		// Find the ship by ID in the playerShips array
		for (var i = 0; i < playerShips.length; i++) {
			if (playerShips[i].id === cell.shipId) {
				ship = playerShips[i];
				break;
			}
		}
		if (ship) {
			var sunk = ship.hit();
			if (sunk) {
				LK.getSound('sunk').play();
				markShipAsSunk(ship, true);
				if (checkVictory(true)) {
					gameState = 'gameOver';
					statusText.setText('Defeat! Enemy sank all your ships!');
					instructionText.setText('');
					LK.showGameOver();
					return;
				}
			}
		}
		statusText.setText('Enemy hit your ship!');
		LK.setTimeout(function () {
			aiTurn();
		}, 2000);
	} else {
		cell.markMiss(true);
		LK.getSound('miss').play();
		currentPlayer = 'player';
		statusText.setText('Enemy missed! Your turn!');
		// Switch back to AI grid for player's turn
		playerGridContainer.visible = false;
		aiGridContainer.visible = true;
	}
}
function markShipAsSunk(ship, isPlayer) {
	var grid = isPlayer ? playerGrid : aiGrid;
	for (var i = 0; i < ship.cells.length; i++) {
		var cellPos = ship.cells[i];
		grid[cellPos.x][cellPos.y].markSunk();
	}
}
function removeShipFromGrid(ship) {
	for (var x = 0; x < GRID_SIZE; x++) {
		for (var y = 0; y < GRID_SIZE; y++) {
			if (playerGrid[x][y].shipId === ship.shipId) {
				playerGrid[x][y].hasShip = false;
				playerGrid[x][y].shipId = -1;
				var cellGraphics = playerGrid[x][y].children[0];
				cellGraphics.tint = 0xFFFFFF;
			}
		}
	}
}
function checkVictory(playerLost) {
	var ships = playerLost ? playerShips : aiShips;
	for (var i = 0; i < ships.length; i++) {
		if (!ships[i].isSunk) {
			return false;
		}
	}
	return true;
}
// Double tap to rotate ship during placement
var lastTapTime = 0;
game.down = function (x, y, obj) {
	if (gameState === 'placement') {
		var currentTime = Date.now();
		if (currentTime - lastTapTime < 300) {
			// Find ship being rotated - check both unplaced and placed ships
			for (var i = 0; i < draggableShips.length; i++) {
				var ship = draggableShips[i];
				var shipBounds = {
					x: ship.x,
					y: ship.y,
					width: ship.isHorizontal ? ship.length * CELL_SIZE : CELL_SIZE,
					height: ship.isHorizontal ? CELL_SIZE : ship.length * CELL_SIZE
				};
				if (x >= shipBounds.x && x <= shipBounds.x + shipBounds.width && y >= shipBounds.y && y <= shipBounds.y + shipBounds.height) {
					if (ship.isPlaced) {
						// Remove ship from grid
						removeShipFromGrid(ship);
						ship.isPlaced = false;
						ship.visible = true;
						placedShipsCount--;
					}
					ship.rotate();
					break;
				}
			}
			instructionText.setText('Double tap ships to rotate, drag to reposition');
		}
		lastTapTime = currentTime;
	}
};
game.move = function (x, y, obj) {
	if (gameState === 'placement' && draggedShip) {
		draggedShip.x = x - draggedShip.width / 2;
		draggedShip.y = y - draggedShip.height / 2;
	}
};
game.up = function (x, y, obj) {
	draggedShip = null;
};
// Initialize the game
initializeGrids();

===================================================================
--- original.js
+++ change.js
@@ -265,8 +265,11 @@
 		statusText.setText('Fire at enemy positions!');
 		instructionText.setText('Tap enemy grid to shoot');
 		startButton.visible = false;
 		placeAIShips();
+		// Show AI grid for player's turn to attack
+		playerGridContainer.visible = false;
+		aiGridContainer.visible = true;
 	}
 };
 // Initialize grids
 function initializeGrids() {
@@ -294,10 +297,10 @@
 			aiGrid[x][y] = cell;
 			aiGridContainer.addChild(cell);
 		}
 	}
-	// Show both grids at all times
-	playerGridContainer.visible = true;
+	// Initialize grid visibility - show AI grid during player turn
+	playerGridContainer.visible = false;
 	aiGridContainer.visible = true;
 	// Add grid labels
 	var playerLabel = new Text2('Your Fleet', {
 		size: 40,
@@ -462,12 +465,15 @@
 	} else {
 		cell.markMiss(false);
 		LK.getSound('miss').play();
 		currentPlayer = 'ai';
-		statusText.setText('Miss! Enemy turn...');
+		statusText.setText('Miss! Enemy is thinking...');
+		// Switch to player grid when AI attacks
+		playerGridContainer.visible = true;
+		aiGridContainer.visible = false;
 		LK.setTimeout(function () {
 			aiTurn();
-		}, 1000);
+		}, 2500);
 	}
 }
 function aiTurn() {
 	if (currentPlayer !== 'ai') return;
@@ -508,14 +514,17 @@
 		}
 		statusText.setText('Enemy hit your ship!');
 		LK.setTimeout(function () {
 			aiTurn();
-		}, 1000);
+		}, 2000);
 	} else {
 		cell.markMiss(true);
 		LK.getSound('miss').play();
 		currentPlayer = 'player';
 		statusText.setText('Enemy missed! Your turn!');
+		// Switch back to AI grid for player's turn
+		playerGridContainer.visible = false;
+		aiGridContainer.visible = true;
 	}
 }
 function markShipAsSunk(ship, isPlayer) {
 	var grid = isPlayer ? playerGrid : aiGrid;