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

/**** 
* Classes
****/ 
var GameGrid = Container.expand(function (isPlayerGrid) {
	var self = Container.call(this);
	self.isPlayerGrid = isPlayerGrid;
	self.cells = [];
	self.ships = [];
	var currentGridSize = gridSize; // Use global gridSize variable
	var cellSize = 60;
	// Initialize grid cells
	for (var row = 0; row < currentGridSize; row++) {
		self.cells[row] = [];
		for (var col = 0; col < currentGridSize; col++) {
			var cell = new GridCell(row, col, isPlayerGrid);
			cell.x = col * cellSize;
			cell.y = row * cellSize;
			self.cells[row][col] = cell;
			self.addChild(cell);
		}
	}
	// Draw grid lines
	for (var i = 0; i <= currentGridSize; i++) {
		// Vertical lines
		var vLine = self.attachAsset('gridLine', {
			width: 2,
			height: currentGridSize * cellSize,
			x: i * cellSize,
			y: 0
		});
		// Horizontal lines
		var hLine = self.attachAsset('gridLine', {
			width: currentGridSize * cellSize,
			height: 2,
			x: 0,
			y: i * cellSize
		});
	}
	self.placeShip = function (startRow, startCol, length, isHorizontal, shipType) {
		var shipCells = [];
		// Check if placement is valid
		for (var i = 0; i < length; i++) {
			var row = isHorizontal ? startRow : startRow + i;
			var col = isHorizontal ? startCol + i : startCol;
			if (row >= currentGridSize || col >= currentGridSize || self.cells[row][col].hasShip) {
				return false;
			}
			shipCells.push({
				row: row,
				col: col
			});
		}
		// Place ship
		var ship = {
			cells: shipCells,
			hits: 0,
			sunk: false,
			type: shipType || 'cruiser',
			length: length,
			isHorizontal: isHorizontal,
			shipGraphic: null
		};
		// Create unified ship graphic that spans all cells
		if (self.isPlayerGrid) {
			var cellSize = 60;
			var shipWidth = isHorizontal ? length * cellSize - 8 : cellSize - 8;
			var shipHeight = isHorizontal ? cellSize - 8 : length * cellSize - 8;
			var shipX = startCol * cellSize + 4;
			var shipY = startRow * cellSize + 4;
			ship.shipGraphic = self.attachAsset(shipType || 'cruiser', {
				width: shipWidth,
				height: shipHeight,
				x: shipX,
				y: shipY
			});
		}
		// Mark cells as having ship but don't create individual graphics
		for (var j = 0; j < shipCells.length; j++) {
			var cellPos = shipCells[j];
			var cell = self.cells[cellPos.row][cellPos.col];
			cell.hasShip = true;
		}
		self.ships.push(ship);
		return true;
	};
	self.checkHit = function (row, col) {
		var cell = self.cells[row][col];
		if (cell.hasShip) {
			cell.markHit();
			// Find which ship was hit
			for (var i = 0; i < self.ships.length; i++) {
				var ship = self.ships[i];
				for (var j = 0; j < ship.cells.length; j++) {
					if (ship.cells[j].row === row && ship.cells[j].col === col) {
						ship.hits++;
						if (ship.hits === ship.cells.length && !ship.sunk) {
							ship.sunk = true;
							LK.getSound('sunk').play();
							// Add fireworks effect for sunk ship
							self.createFireworks(ship.cells);
							updateFleetStatus();
							return 'sunk';
						}
						return 'hit';
					}
				}
			}
		} else {
			cell.markMiss();
			return 'miss';
		}
	};
	self.allShipsSunk = function () {
		for (var i = 0; i < self.ships.length; i++) {
			if (!self.ships[i].sunk) {
				return false;
			}
		}
		return true;
	};
	self.createFireworks = function (shipCells) {
		var cellSize = 60;
		for (var i = 0; i < shipCells.length; i++) {
			var cellPos = shipCells[i];
			var centerX = cellPos.col * cellSize + cellSize / 2;
			var centerY = cellPos.row * cellSize + cellSize / 2;
			// Create multiple firework particles
			for (var f = 0; f < 5; f++) {
				var firework = self.attachAsset('firework', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: centerX,
					y: centerY,
					alpha: 1,
					scaleX: 0.5,
					scaleY: 0.5
				});
				var angle = f / 5 * Math.PI * 2;
				var distance = 50 + Math.random() * 30;
				var targetX = centerX + Math.cos(angle) * distance;
				var targetY = centerY + Math.sin(angle) * distance;
				tween(firework, {
					x: targetX,
					y: targetY,
					scaleX: 1.2,
					scaleY: 1.2,
					alpha: 0
				}, {
					duration: 800 + Math.random() * 400,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						firework.destroy();
					}
				});
			}
		}
	};
	return self;
});
var GridCell = Container.expand(function (row, col, isPlayerGrid) {
	var self = Container.call(this);
	self.row = row;
	self.col = col;
	self.isPlayerGrid = isPlayerGrid;
	self.hasShip = false;
	self.isHit = false;
	self.isMiss = false;
	var cellSize = 60;
	var waterTile = self.attachAsset('water', {
		width: cellSize,
		height: cellSize,
		x: 0,
		y: 0,
		color: 0xffffff
	});
	var shipGraphic = null;
	var hitMarker = null;
	var missMarker = null;
	self.placeShip = function (shipType, segmentIndex, totalLength, isHorizontal) {
		// Only show ship graphics on player's own grid, hide enemy ships
		if (!shipGraphic && self.isPlayerGrid) {
			shipType = shipType || 'cruiser';
			// Create single unified ship graphic that spans the entire ship length
			var shipWidth = isHorizontal ? totalLength * cellSize - 8 : cellSize - 8;
			var shipHeight = isHorizontal ? cellSize - 8 : totalLength * cellSize - 8;
			// Calculate position to center the ship across all its cells
			var shipX = isHorizontal ? segmentIndex * cellSize + 4 - segmentIndex * cellSize : 4;
			var shipY = isHorizontal ? 4 : segmentIndex * cellSize + 4 - segmentIndex * cellSize;
			// Only create the ship graphic on the first segment (bow)
			if (segmentIndex === 0) {
				shipGraphic = self.attachAsset(shipType, {
					width: shipWidth,
					height: shipHeight,
					x: shipX,
					y: shipY
				});
			}
		}
		self.hasShip = true;
	};
	self.removeShip = function () {
		// Ship graphics are now handled at the GameGrid level
		// Just mark the cell as not having a ship
		self.hasShip = false;
	};
	self.markHit = function () {
		if (!self.isHit) {
			hitMarker = self.attachAsset('hit', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: cellSize / 2,
				y: cellSize / 2
			});
			self.isHit = true;
			LK.getSound('hit').play();
			LK.getSound('shoot').play();
			// Add explosion effect
			var explosion = self.attachAsset('explosion', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: cellSize / 2,
				y: cellSize / 2,
				alpha: 0
			});
			tween(explosion, {
				alpha: 1,
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 300,
				onFinish: function onFinish() {
					tween(explosion, {
						alpha: 0
					}, {
						duration: 200,
						onFinish: function onFinish() {
							explosion.destroy();
						}
					});
				}
			});
		}
	};
	self.markMiss = function () {
		if (!self.isMiss) {
			missMarker = self.attachAsset('miss', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: cellSize / 2,
				y: cellSize / 2
			});
			self.isMiss = true;
			LK.getSound('miss').play();
			// Add missile effect for miss
			var missile = self.attachAsset('missile', {
				anchorX: 0.5,
				anchorY: 1,
				x: cellSize / 2,
				y: -50,
				alpha: 0.8
			});
			LK.getSound('shoot').play();
			tween(missile, {
				y: cellSize / 2,
				alpha: 0.3
			}, {
				duration: 400,
				onFinish: function onFinish() {
					missile.destroy();
				}
			});
		}
	};
	self.down = function (x, y, obj) {
		if (gamePhase === 'placement' && self.isPlayerGrid) {
			handleShipPlacement(self.row, self.col);
		} else if (gamePhase === 'battle' && !self.isPlayerGrid && !self.isHit && !self.isMiss && !crosshairActive) {
			// Only allow direct clicking if crosshair is not active
			handlePlayerShot(self.row, self.col);
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Gun turrets
// Deck details
// Hull details
// Submarine - smallest
// Destroyer - smaller
// Cruiser - medium
// Battleship - large
// Aircraft Carrier - long and wide
// Game state
var gamePhase = 'placement'; // 'placement', 'battle', 'gameOver'
var currentShipIndex = 0;
var isHorizontal = true;
var playerTurn = true;
var aiTargets = [];
var aiLastHit = null;
var aiHuntMode = false;
var crosshairActive = false;
var crosshairRow = 0;
var crosshairCol = 0;
var crosshairGraphic = null;
var airBombardmentUsed = false;
var airBombardmentInProgress = false;
var submarineAttackUsed = false;
var submarineAttackInProgress = false;
var sihaAttackUsed = false;
var sihaAttackInProgress = false;
var lastAttackType = null; // Track the last attack type to prevent consecutive use
var aiAttackOptions = ['air', 'submarine', 'siha']; // Available AI attack options
var aiLastAttackType = null; // Track AI's last attack type
var aiAttackCooldowns = {
	air: false,
	submarine: false,
	siha: false
}; // Track which AI attacks have been used
// Attack rights tracking
var playerAttackRights = {
	air: 2,
	submarine: 2,
	siha: 2
};
var aiAttackRights = {
	air: 2,
	submarine: 2,
	siha: 2
};
// Ship sizes to place - realistic naval fleet
var shipSizes = [5, 4, 3, 3, 2]; // Carrier, Battleship, Cruiser, Cruiser, Destroyer
var shipTypes = ['Uçak Gemisi', 'Savaş Gemisi', 'Kruvazör', 'Kruvazör', 'Muhrip'];
var shipAssets = ['carrier', 'battleship', 'cruiser', 'cruiser', 'destroyer'];
// Create grids
var playerGrid = new GameGrid(true);
var enemyGrid = new GameGrid(false);
// Scale up grids for better visibility - increased for closer view
playerGrid.scaleX = 2.0;
playerGrid.scaleY = 2.0;
enemyGrid.scaleX = 2.0;
enemyGrid.scaleY = 2.0;
// Center grids on screen
var gridWidth = 8 * 60 * 2.0; // 8 cells * 60px * scale
var screenCenterX = 2048 / 2;
var gridCenterX = gridWidth / 2;
playerGrid.x = screenCenterX - gridCenterX;
playerGrid.y = 1300;
enemyGrid.x = screenCenterX - gridCenterX;
enemyGrid.y = 300;
game.addChild(playerGrid);
game.addChild(enemyGrid);
// Add touch support to enemy grid for crosshair positioning
enemyGrid.down = function (x, y, obj) {
	if (crosshairActive && gamePhase === 'battle' && playerTurn) {
		// Convert touch position to grid coordinates
		var cellSize = 60;
		var scale = enemyGrid.scaleX;
		var gridX = (x - enemyGrid.x) / scale;
		var gridY = (y - enemyGrid.y) / scale;
		var newCol = Math.floor(gridX / cellSize);
		var newRow = Math.floor(gridY / cellSize);
		// Keep crosshair within grid bounds
		if (newRow >= 0 && newRow < gridSize && newCol >= 0 && newCol < gridSize) {
			crosshairRow = newRow;
			crosshairCol = newCol;
			updateCrosshairPosition();
		}
	}
};
enemyGrid.move = function (x, y, obj) {
	if (crosshairActive && gamePhase === 'battle' && playerTurn) {
		// Convert touch position to grid coordinates during drag
		var cellSize = 60;
		var scale = enemyGrid.scaleX;
		var gridX = (x - enemyGrid.x) / scale;
		var gridY = (y - enemyGrid.y) / scale;
		var newCol = Math.floor(gridX / cellSize);
		var newRow = Math.floor(gridY / cellSize);
		// Keep crosshair within grid bounds
		if (newRow >= 0 && newRow < gridSize && newCol >= 0 && newCol < gridSize) {
			crosshairRow = newRow;
			crosshairCol = newCol;
			updateCrosshairPosition();
		}
	}
};
// Hide enemy grid during placement phase
enemyGrid.visible = false;
// UI Elements
var statusText = new Text2('Gemilerinizi yerleştirin. ' + shipSizes[0] + ' uzunluğunda gemi yerleştirmek için dokunun', {
	size: 40,
	fill: 0xFFFFFF
});
statusText.anchor.set(0.5, 0);
LK.gui.top.addChild(statusText);
var turnText = new Text2('', {
	size: 35,
	fill: 0xFFFF00
});
turnText.anchor.set(0.5, 0);
turnText.y = 80;
LK.gui.top.addChild(turnText);
// Labels for grids
var enemyLabel = new Text2('Düşman Suları', {
	size: 45,
	fill: 0xFF6666
});
enemyLabel.anchor.set(0.5, 0.5);
enemyLabel.x = enemyGrid.x + 8 * 60 * 1.5 / 2;
enemyLabel.y = enemyGrid.y - 60;
game.addChild(enemyLabel);
var playerLabel = new Text2('Filonuz', {
	size: 45,
	fill: 0x66FF66
});
playerLabel.anchor.set(0.5, 0.5);
playerLabel.x = playerGrid.x + 8 * 60 * 1.5 / 2;
playerLabel.y = playerGrid.y - 60;
game.addChild(playerLabel);
// Rotation button for ship placement
var rotateButton = new Text2('Gemiyi Çevir', {
	size: 60,
	fill: 0xFFFF00
});
rotateButton.anchor.set(0.5, 0.5);
rotateButton.x = 300;
rotateButton.y = 1200;
game.addChild(rotateButton);
rotateButton.down = function (x, y, obj) {
	if (gamePhase === 'placement') {
		isHorizontal = !isHorizontal;
		updateStatusText();
		updateShipPreview();
	}
};
// Auto-placement button
var autoPlaceButton = new Text2('Otomatik Yerleştir', {
	size: 60,
	fill: 0x00FF00
});
autoPlaceButton.anchor.set(0.5, 0.5);
autoPlaceButton.x = 300;
autoPlaceButton.y = 1300;
game.addChild(autoPlaceButton);
autoPlaceButton.down = function (x, y, obj) {
	if (gamePhase === 'placement') {
		autoPlacePlayerShips();
	}
};
// Start battle button
var startBattleButton = new Text2('Savaşı Başlat', {
	size: 60,
	fill: 0xFF0000
});
startBattleButton.anchor.set(0.5, 0.5);
startBattleButton.x = 300;
startBattleButton.y = 1400;
game.addChild(startBattleButton);
startBattleButton.down = function (x, y, obj) {
	if (gamePhase === 'placement' && currentShipIndex >= shipSizes.length) {
		placeAIShips();
		gamePhase = 'battle';
		rotateButton.visible = false;
		autoPlaceButton.visible = false;
		startBattleButton.visible = false;
		enemyGrid.visible = true;
		airBombardmentButton.visible = true;
		submarineAttackButton.visible = true;
		sihaAttackButton.visible = true;
		updateStatusText();
	}
};
// Air bombardment button
var airBombardmentButton = new Container();
airBombardmentButton.x = 50;
airBombardmentButton.y = 700;
airBombardmentButton.visible = false;
game.addChild(airBombardmentButton);
// Button background
var airButtonBg = airBombardmentButton.attachAsset('water', {
	width: 420,
	height: 90,
	x: -10,
	y: -45,
	color: 0xFF6600
});
airButtonBg.alpha = 0.9;
// Button border
var airButtonBorder = airBombardmentButton.attachAsset('gridLine', {
	width: 424,
	height: 94,
	x: -12,
	y: -47,
	color: 0xFFFFFF
});
airButtonBorder.alpha = 0.8;
// Button text
var airButtonText = new Text2('🚁 Hava Bombardımanı', {
	size: 42,
	fill: 0xFFFFFF
});
airButtonText.anchor.set(0, 0.5);
airButtonText.x = 15;
airButtonText.y = 0;
airBombardmentButton.addChild(airButtonText);
// Button press effect
airBombardmentButton.down = function (x, y, obj) {
	if (gamePhase === 'battle' && playerTurn && !airBombardmentUsed && !airBombardmentInProgress && lastAttackType !== 'air') {
		// Press effect
		tween(airBombardmentButton, {
			scaleX: 0.95,
			scaleY: 0.95
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(airBombardmentButton, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 100
				});
			}
		});
		executeAirBombardment();
	}
};
// Submarine attack button
var submarineAttackButton = new Container();
submarineAttackButton.x = 50;
submarineAttackButton.y = 1000;
submarineAttackButton.visible = false;
game.addChild(submarineAttackButton);
// Button background
var subButtonBg = submarineAttackButton.attachAsset('water', {
	width: 420,
	height: 90,
	x: -10,
	y: -45,
	color: 0x0066CC
});
subButtonBg.alpha = 0.9;
// Button border
var subButtonBorder = submarineAttackButton.attachAsset('gridLine', {
	width: 424,
	height: 94,
	x: -12,
	y: -47,
	color: 0xFFFFFF
});
subButtonBorder.alpha = 0.8;
// Button text
var subButtonText = new Text2('🚢 Denizaltı Saldırısı', {
	size: 42,
	fill: 0xFFFFFF
});
subButtonText.anchor.set(0, 0.5);
subButtonText.x = 15;
subButtonText.y = 0;
submarineAttackButton.addChild(subButtonText);
// Button press effect
submarineAttackButton.down = function (x, y, obj) {
	if (gamePhase === 'battle' && playerTurn && !submarineAttackUsed && !submarineAttackInProgress && lastAttackType !== 'submarine') {
		// Press effect
		tween(submarineAttackButton, {
			scaleX: 0.95,
			scaleY: 0.95
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(submarineAttackButton, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 100
				});
			}
		});
		executeSubmarineAttack();
	}
};
// SIHA attack button
var sihaAttackButton = new Container();
sihaAttackButton.x = 50;
sihaAttackButton.y = 1300;
sihaAttackButton.visible = false;
game.addChild(sihaAttackButton);
// Button background
var sihaButtonBg = sihaAttackButton.attachAsset('water', {
	width: 420,
	height: 90,
	x: -10,
	y: -45,
	color: 0x9900FF
});
sihaButtonBg.alpha = 0.9;
// Button border
var sihaButtonBorder = sihaAttackButton.attachAsset('gridLine', {
	width: 424,
	height: 94,
	x: -12,
	y: -47,
	color: 0xFFFFFF
});
sihaButtonBorder.alpha = 0.8;
// Button text
var sihaButtonText = new Text2('🛩️ SİHA Saldırısı', {
	size: 42,
	fill: 0xFFFFFF
});
sihaButtonText.anchor.set(0, 0.5);
sihaButtonText.x = 15;
sihaButtonText.y = 0;
sihaAttackButton.addChild(sihaButtonText);
// Button press effect
sihaAttackButton.down = function (x, y, obj) {
	if (gamePhase === 'battle' && playerTurn && !sihaAttackUsed && !sihaAttackInProgress && lastAttackType !== 'siha') {
		// Press effect
		tween(sihaAttackButton, {
			scaleX: 0.95,
			scaleY: 0.95
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(sihaAttackButton, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 100
				});
			}
		});
		executeSihaAttack();
	}
};
// Crosshair control buttons
var crosshairControlsContainer = new Container();
crosshairControlsContainer.x = 1700;
crosshairControlsContainer.y = 2200;
crosshairControlsContainer.visible = false;
game.addChild(crosshairControlsContainer);
// Up button with background
var upButtonBg = crosshairControlsContainer.attachAsset('water', {
	width: 80,
	height: 80,
	x: -40,
	y: -140,
	color: 0x333333,
	alpha: 0.8
});
var upButton = new Text2('↑', {
	size: 80,
	fill: 0x00FFFF
});
upButton.anchor.set(0.5, 0.5);
upButton.x = 0;
upButton.y = -100;
crosshairControlsContainer.addChild(upButton);
upButton.down = function (x, y, obj) {
	// Press effect
	tween(upButton, {
		scaleX: 0.8,
		scaleY: 0.8
	}, {
		duration: 100,
		onFinish: function onFinish() {
			tween(upButton, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 100
			});
		}
	});
	moveCrosshair(-1, 0);
};
// Down button with background
var downButtonBg = crosshairControlsContainer.attachAsset('water', {
	width: 80,
	height: 80,
	x: -40,
	y: 60,
	color: 0x333333,
	alpha: 0.8
});
var downButton = new Text2('↓', {
	size: 80,
	fill: 0x00FFFF
});
downButton.anchor.set(0.5, 0.5);
downButton.x = 0;
downButton.y = 100;
crosshairControlsContainer.addChild(downButton);
downButton.down = function (x, y, obj) {
	// Press effect
	tween(downButton, {
		scaleX: 0.8,
		scaleY: 0.8
	}, {
		duration: 100,
		onFinish: function onFinish() {
			tween(downButton, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 100
			});
		}
	});
	moveCrosshair(1, 0);
};
// Left button with background
var leftButtonBg = crosshairControlsContainer.attachAsset('water', {
	width: 80,
	height: 80,
	x: -140,
	y: -40,
	color: 0x333333,
	alpha: 0.8
});
var leftButton = new Text2('←', {
	size: 80,
	fill: 0x00FFFF
});
leftButton.anchor.set(0.5, 0.5);
leftButton.x = -100;
leftButton.y = 0;
crosshairControlsContainer.addChild(leftButton);
leftButton.down = function (x, y, obj) {
	// Press effect
	tween(leftButton, {
		scaleX: 0.8,
		scaleY: 0.8
	}, {
		duration: 100,
		onFinish: function onFinish() {
			tween(leftButton, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 100
			});
		}
	});
	moveCrosshair(0, -1);
};
// Right button with background
var rightButtonBg = crosshairControlsContainer.attachAsset('water', {
	width: 80,
	height: 80,
	x: 60,
	y: -40,
	color: 0x333333,
	alpha: 0.8
});
var rightButton = new Text2('→', {
	size: 80,
	fill: 0x00FFFF
});
rightButton.anchor.set(0.5, 0.5);
rightButton.x = 100;
rightButton.y = 0;
crosshairControlsContainer.addChild(rightButton);
rightButton.down = function (x, y, obj) {
	// Press effect
	tween(rightButton, {
		scaleX: 0.8,
		scaleY: 0.8
	}, {
		duration: 100,
		onFinish: function onFinish() {
			tween(rightButton, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 100
			});
		}
	});
	moveCrosshair(0, 1);
};
// Fire button with enhanced styling
var fireButtonBg = crosshairControlsContainer.attachAsset('water', {
	width: 120,
	height: 80,
	x: -60,
	y: 160,
	color: 0xFF0000,
	alpha: 0.9
});
var fireButton = new Text2('🎯 ATEŞ!', {
	size: 50,
	fill: 0xFFFFFF
});
fireButton.anchor.set(0.5, 0.5);
fireButton.x = 0;
fireButton.y = 200;
crosshairControlsContainer.addChild(fireButton);
fireButton.down = function (x, y, obj) {
	// Enhanced press effect
	tween(fireButton, {
		scaleX: 0.9,
		scaleY: 0.9
	}, {
		duration: 80,
		onFinish: function onFinish() {
			tween(fireButton, {
				scaleX: 1.1,
				scaleY: 1.1
			}, {
				duration: 80,
				onFinish: function onFinish() {
					tween(fireButton, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 80
					});
				}
			});
		}
	});
	fireCrosshair();
};
// Activate crosshair button
var activateCrosshairButton = new Text2('NİŞANGAH', {
	size: 50,
	fill: 0x00FFFF
});
activateCrosshairButton.anchor.set(0.5, 0.5);
activateCrosshairButton.x = 1700;
activateCrosshairButton.y = 2050;
activateCrosshairButton.visible = false;
game.addChild(activateCrosshairButton);
activateCrosshairButton.down = function (x, y, obj) {
	if (gamePhase === 'battle' && playerTurn && !crosshairActive) {
		crosshairActive = true;
		crosshairRow = Math.floor(gridSize / 2);
		crosshairCol = Math.floor(gridSize / 2);
		if (!crosshairGraphic) {
			createCrosshair();
		}
		crosshairGraphic.visible = true;
		updateCrosshairPosition();
		crosshairControlsContainer.visible = true;
	}
};
// Attack rights display
var attackRightsContainer = new Container();
attackRightsContainer.x = 50;
attackRightsContainer.y = playerGrid.y + 200;
game.addChild(attackRightsContainer);
var attackRightsTitle = new Text2('Saldırı Hakları', {
	size: 60,
	fill: 0xFFFFFF
});
attackRightsTitle.anchor.set(0, 0);
attackRightsTitle.x = 0;
attackRightsTitle.y = 0;
attackRightsContainer.addChild(attackRightsTitle);
// Player attack rights
var playerRightsTitle = new Text2('Oyuncu:', {
	size: 50,
	fill: 0x00FF00
});
playerRightsTitle.anchor.set(0, 0);
playerRightsTitle.x = 0;
playerRightsTitle.y = 60;
attackRightsContainer.addChild(playerRightsTitle);
var playerAirRightsText = new Text2('Hava: 2', {
	size: 45,
	fill: 0x00FF00
});
playerAirRightsText.anchor.set(0, 0);
playerAirRightsText.x = 0;
playerAirRightsText.y = 110;
attackRightsContainer.addChild(playerAirRightsText);
var playerSubRightsText = new Text2('Denizaltı: 2', {
	size: 45,
	fill: 0x00FF00
});
playerSubRightsText.anchor.set(0, 0);
playerSubRightsText.x = 0;
playerSubRightsText.y = 160;
attackRightsContainer.addChild(playerSubRightsText);
var playerSihaRightsText = new Text2('SİHA: 2', {
	size: 45,
	fill: 0x00FF00
});
playerSihaRightsText.anchor.set(0, 0);
playerSihaRightsText.x = 0;
playerSihaRightsText.y = 210;
attackRightsContainer.addChild(playerSihaRightsText);
// AI attack rights
var aiRightsTitle = new Text2('Düşman:', {
	size: 50,
	fill: 0xFF0000
});
aiRightsTitle.anchor.set(0, 0);
aiRightsTitle.x = 0;
aiRightsTitle.y = 280;
attackRightsContainer.addChild(aiRightsTitle);
var aiAirRightsText = new Text2('Hava: 2', {
	size: 45,
	fill: 0xFF0000
});
aiAirRightsText.anchor.set(0, 0);
aiAirRightsText.x = 0;
aiAirRightsText.y = 330;
attackRightsContainer.addChild(aiAirRightsText);
var aiSubRightsText = new Text2('Denizaltı: 2', {
	size: 45,
	fill: 0xFF0000
});
aiSubRightsText.anchor.set(0, 0);
aiSubRightsText.x = 0;
aiSubRightsText.y = 380;
attackRightsContainer.addChild(aiSubRightsText);
var aiSihaRightsText = new Text2('SİHA: 2', {
	size: 45,
	fill: 0xFF0000
});
aiSihaRightsText.anchor.set(0, 0);
aiSihaRightsText.x = 0;
aiSihaRightsText.y = 430;
attackRightsContainer.addChild(aiSihaRightsText);
function createCrosshair() {
	if (crosshairGraphic) {
		crosshairGraphic.destroy();
	}
	// Create crosshair container for multiple elements
	crosshairGraphic = new Container();
	game.addChild(crosshairGraphic);
	// Create grid alignment indicators
	var alignmentIndicators = new Container();
	crosshairGraphic.addChild(alignmentIndicators);
	// Create horizontal grid alignment lines
	for (var i = 0; i < gridSize + 1; i++) {
		var hGridLine = alignmentIndicators.attachAsset('crosshairH', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 0,
			y: (i - gridSize / 2) * 60 * enemyGrid.scaleX,
			width: gridSize * 60 * enemyGrid.scaleX,
			height: 1,
			alpha: 0.1,
			color: 0x00FFFF
		});
	}
	// Create vertical grid alignment lines  
	for (var i = 0; i < gridSize + 1; i++) {
		var vGridLine = alignmentIndicators.attachAsset('crosshairV', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: (i - gridSize / 2) * 60 * enemyGrid.scaleX,
			y: 0,
			width: 1,
			height: gridSize * 60 * enemyGrid.scaleY,
			alpha: 0.1,
			color: 0x00FFFF
		});
	}
	// Create outer targeting circle with dynamic sizing
	var outerCircle = crosshairGraphic.attachAsset('crosshair', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: 0,
		alpha: 0.4,
		scaleX: 1.2,
		scaleY: 1.2,
		color: 0x00FFFF
	});
	// Create precision targeting square
	var targetingSquare = crosshairGraphic.attachAsset('crosshair', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: 0,
		width: 60 * enemyGrid.scaleX,
		height: 60 * enemyGrid.scaleY,
		alpha: 0.3,
		color: 0xFFFF00
	});
	// Create horizontal crosshair line (red)
	var hLine = crosshairGraphic.attachAsset('crosshairH', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: 0,
		alpha: 0.9,
		width: 80,
		height: 4
	});
	// Create vertical crosshair line (red)
	var vLine = crosshairGraphic.attachAsset('crosshairV', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: 0,
		alpha: 0.9,
		width: 4,
		height: 80
	});
	// Create center dot for precise aiming
	var centerDot = crosshairGraphic.attachAsset('crosshairV', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: 0,
		width: 10,
		height: 10,
		alpha: 1.0,
		color: 0xFF0000
	});
	// Add coordinate display
	var coordDisplay = new Text2('A1', {
		size: 30,
		fill: 0xFFFFFF
	});
	coordDisplay.anchor.set(0.5, 0.5);
	coordDisplay.x = 0;
	coordDisplay.y = -80;
	crosshairGraphic.addChild(coordDisplay);
	// Store references for animations
	crosshairGraphic.outerCircle = outerCircle;
	crosshairGraphic.targetingSquare = targetingSquare;
	crosshairGraphic.coordDisplay = coordDisplay;
	crosshairGraphic.alignmentIndicators = alignmentIndicators;
	// Add touch-responsive functionality to crosshair
	crosshairGraphic.down = function (x, y, obj) {
		if (crosshairActive && gamePhase === 'battle' && playerTurn) {
			// Convert touch position to grid coordinates
			var cellSize = 60;
			var scale = enemyGrid.scaleX;
			var gridX = (x - enemyGrid.x) / scale;
			var gridY = (y - enemyGrid.y) / scale;
			var newCol = Math.floor(gridX / cellSize);
			var newRow = Math.floor(gridY / cellSize);
			// Keep crosshair within grid bounds
			if (newRow >= 0 && newRow < gridSize && newCol >= 0 && newCol < gridSize) {
				crosshairRow = newRow;
				crosshairCol = newCol;
				updateCrosshairPosition();
			}
		}
	};
	crosshairGraphic.move = function (x, y, obj) {
		if (crosshairActive && gamePhase === 'battle' && playerTurn) {
			// Convert touch position to grid coordinates during drag
			var cellSize = 60;
			var scale = enemyGrid.scaleX;
			var gridX = (x - enemyGrid.x) / scale;
			var gridY = (y - enemyGrid.y) / scale;
			var newCol = Math.floor(gridX / cellSize);
			var newRow = Math.floor(gridY / cellSize);
			// Keep crosshair within grid bounds
			if (newRow >= 0 && newRow < gridSize && newCol >= 0 && newCol < gridSize) {
				crosshairRow = newRow;
				crosshairCol = newCol;
				updateCrosshairPosition();
			}
		}
	};
	// Add pulsing animation to make crosshair more visible
	tween(outerCircle, {
		scaleX: 1.4,
		scaleY: 1.4,
		alpha: 0.6
	}, {
		duration: 1200,
		easing: tween.easeInOut,
		loop: true,
		reverse: true
	});
	// Add targeting square pulse
	tween(targetingSquare, {
		alpha: 0.6,
		scaleX: 1.1,
		scaleY: 1.1
	}, {
		duration: 800,
		easing: tween.easeInOut,
		loop: true,
		reverse: true
	});
	updateCrosshairPosition();
}
function updateCrosshairPosition() {
	if (crosshairGraphic && enemyGrid.visible) {
		var cellSize = 60;
		var scale = enemyGrid.scaleX;
		var targetX = enemyGrid.x + (crosshairCol * cellSize + cellSize / 2) * scale;
		var targetY = enemyGrid.y + (crosshairRow * cellSize + cellSize / 2) * scale;
		// Update coordinate display (A1, B2, etc.)
		var coordText = String.fromCharCode(65 + crosshairCol) + (crosshairRow + 1);
		if (crosshairGraphic.coordDisplay) {
			crosshairGraphic.coordDisplay.setText(coordText);
		}
		// Check if target cell is already hit/miss for visual feedback
		var targetCell = enemyGrid.cells[crosshairRow][crosshairCol];
		var isValidTarget = !targetCell.isHit && !targetCell.isMiss;
		// Update targeting square color based on validity
		if (crosshairGraphic.targetingSquare) {
			var targetColor = isValidTarget ? 0x00FF00 : 0xFF0000;
			crosshairGraphic.targetingSquare.tint = targetColor;
			crosshairGraphic.targetingSquare.alpha = isValidTarget ? 0.4 : 0.2;
		}
		// Update crosshair color for feedback
		if (crosshairGraphic.outerCircle) {
			crosshairGraphic.outerCircle.tint = isValidTarget ? 0x00FFFF : 0xFF6666;
		}
		// Enhanced smooth movement animation with grid snapping
		tween(crosshairGraphic, {
			x: targetX,
			y: targetY
		}, {
			duration: 200,
			easing: tween.easeOutQuad,
			onUpdate: function onUpdate() {
				// Add subtle grid snapping feedback
				if (crosshairGraphic.alignmentIndicators) {
					crosshairGraphic.alignmentIndicators.alpha = 0.3;
				}
			},
			onFinish: function onFinish() {
				// Fade out alignment indicators
				if (crosshairGraphic.alignmentIndicators) {
					tween(crosshairGraphic.alignmentIndicators, {
						alpha: 0.1
					}, {
						duration: 300,
						easing: tween.easeOut
					});
				}
				// Add confirmation pulse for valid targets
				if (isValidTarget && crosshairGraphic.targetingSquare) {
					tween(crosshairGraphic.targetingSquare, {
						scaleX: 1.3,
						scaleY: 1.3,
						alpha: 0.7
					}, {
						duration: 150,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							tween(crosshairGraphic.targetingSquare, {
								scaleX: 1.0,
								scaleY: 1.0,
								alpha: 0.4
							}, {
								duration: 150,
								easing: tween.easeIn
							});
						}
					});
				}
			}
		});
	}
}
function moveCrosshair(deltaRow, deltaCol) {
	if (crosshairActive) {
		var newRow = crosshairRow + deltaRow;
		var newCol = crosshairCol + deltaCol;
		// Keep crosshair within grid bounds
		if (newRow >= 0 && newRow < gridSize && newCol >= 0 && newCol < gridSize) {
			crosshairRow = newRow;
			crosshairCol = newCol;
			// Add directional movement feedback
			if (crosshairGraphic) {
				// Create movement indicator
				var direction = '';
				if (deltaRow < 0) direction = '↑';else if (deltaRow > 0) direction = '↓';else if (deltaCol < 0) direction = '←';else if (deltaCol > 0) direction = '→';
				if (direction) {
					var moveIndicator = new Text2(direction, {
						size: 40,
						fill: 0x00FFFF
					});
					moveIndicator.anchor.set(0.5, 0.5);
					moveIndicator.x = crosshairGraphic.x + deltaCol * 30;
					moveIndicator.y = crosshairGraphic.y + deltaRow * 30;
					moveIndicator.alpha = 0.8;
					game.addChild(moveIndicator);
					// Animate and remove indicator
					tween(moveIndicator, {
						alpha: 0,
						scaleX: 1.5,
						scaleY: 1.5,
						y: moveIndicator.y + deltaRow * 20
					}, {
						duration: 400,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							moveIndicator.destroy();
						}
					});
				}
			}
			updateCrosshairPosition();
		}
	}
}
function fireCrosshair() {
	if (crosshairActive && playerTurn && gamePhase === 'battle') {
		var cell = enemyGrid.cells[crosshairRow][crosshairCol];
		if (!cell.isHit && !cell.isMiss) {
			handlePlayerShot(crosshairRow, crosshairCol);
			crosshairActive = false;
			if (crosshairGraphic) {
				crosshairGraphic.visible = false;
			}
		}
	}
}
function updateAttackRightsDisplay() {
	playerAirRightsText.setText('Hava: ' + playerAttackRights.air);
	playerSubRightsText.setText('Denizaltı: ' + playerAttackRights.submarine);
	playerSihaRightsText.setText('SİHA: ' + playerAttackRights.siha);
	aiAirRightsText.setText('Hava: ' + aiAttackRights.air);
	aiSubRightsText.setText('Denizaltı: ' + aiAttackRights.submarine);
	aiSihaRightsText.setText('SİHA: ' + aiAttackRights.siha);
	// Update button visibility based on available rights
	if (gamePhase === 'battle') {
		attackRightsContainer.visible = true;
		airBombardmentButton.visible = playerAttackRights.air > 0 && lastAttackType !== 'air' && playerTurn;
		submarineAttackButton.visible = playerAttackRights.submarine > 0 && lastAttackType !== 'submarine' && playerTurn;
		sihaAttackButton.visible = playerAttackRights.siha > 0 && lastAttackType !== 'siha' && playerTurn;
		activateCrosshairButton.visible = playerTurn && !crosshairActive;
		crosshairControlsContainer.visible = crosshairActive;
	} else {
		attackRightsContainer.visible = false;
		activateCrosshairButton.visible = false;
		crosshairControlsContainer.visible = false;
	}
}
// Ship preview container for placement phase
var shipPreviewContainer = new Container();
shipPreviewContainer.x = 2048 / 2;
shipPreviewContainer.y = 1050; // Position above player grid (player grid is at y=1300)
game.addChild(shipPreviewContainer);
function updateShipPreview() {
	// Clear existing preview
	for (var i = shipPreviewContainer.children.length - 1; i >= 0; i--) {
		shipPreviewContainer.children[i].destroy();
	}
	if (gamePhase === 'placement' && currentShipIndex < shipSizes.length) {
		var shipLength = shipSizes[currentShipIndex];
		var shipType = shipAssets[currentShipIndex];
		var cellSize = 60;
		// Create preview ship graphic
		var previewWidth = isHorizontal ? shipLength * cellSize - 8 : cellSize - 8;
		var previewHeight = isHorizontal ? cellSize - 8 : shipLength * cellSize - 8;
		var previewX = isHorizontal ? -(previewWidth / 2) : -(previewWidth / 2);
		var previewY = isHorizontal ? -(previewHeight / 2) : -(previewHeight / 2);
		var shipPreview = shipPreviewContainer.attachAsset(shipType, {
			width: previewWidth,
			height: previewHeight,
			x: previewX,
			y: previewY,
			alpha: 0.8
		});
		// Add ship name label
		var shipNameText = new Text2(shipTypes[currentShipIndex], {
			size: 35,
			fill: 0xFFFFFF
		});
		shipNameText.anchor.set(0.5, 0.5);
		shipNameText.x = 0;
		shipNameText.y = previewHeight / 2 + 50;
		shipPreviewContainer.addChild(shipNameText);
		// Add orientation label
		var orientationText = new Text2(isHorizontal ? 'Yatay' : 'Dikey', {
			size: 30,
			fill: 0xFFFF00
		});
		orientationText.anchor.set(0.5, 0.5);
		orientationText.x = 0;
		orientationText.y = previewHeight / 2 + 90;
		shipPreviewContainer.addChild(orientationText);
	}
}
function updateStatusText() {
	if (gamePhase === 'placement') {
		if (currentShipIndex < shipSizes.length) {
			var orientation = isHorizontal ? 'yatay' : 'dikey';
			var shipName = shipTypes[currentShipIndex];
			statusText.setText(shipName + ' yerleştirin (' + shipSizes[currentShipIndex] + ' kare, ' + orientation + ')');
			updateShipPreview();
		} else {
			statusText.setText('Tüm gemiler yerleştirildi! Savaşı başlatmak için butona tıklayın.');
			shipPreviewContainer.visible = false;
		}
	} else if (gamePhase === 'battle') {
		shipPreviewContainer.visible = false;
		if (playerTurn && !airBombardmentInProgress && !submarineAttackInProgress && !sihaAttackInProgress) {
			var bombardmentText = playerAttackRights.air > 0 && lastAttackType !== 'air' ? ' | Hava bombardımanı mevcut!' : '';
			var submarineText = playerAttackRights.submarine > 0 && lastAttackType !== 'submarine' ? ' | Denizaltı saldırısı mevcut!' : '';
			var sihaText = playerAttackRights.siha > 0 && lastAttackType !== 'siha' ? ' | SİHA saldırısı mevcut!' : '';
			var crosshairText = crosshairActive ? ' | Nişangahı dokunarak hareket ettirin veya ok tuşları kullanın!' : ' | Nişangah için butona basın!';
			statusText.setText('Sıra sizde - Düşman ızgarasına ateş edin!' + bombardmentText + submarineText + sihaText + crosshairText);
			turnText.setText('SİZİN SIRANIZ');
		} else if (airBombardmentInProgress) {
			statusText.setText('Hava bombardımanı devam ediyor...');
			turnText.setText('HAVA SALDIRISI');
			airBombardmentButton.visible = false;
			submarineAttackButton.visible = false;
			sihaAttackButton.visible = false;
		} else if (submarineAttackInProgress) {
			statusText.setText('Denizaltı saldırısı devam ediyor...');
			turnText.setText('DENİZALTI SALDIRISI');
			airBombardmentButton.visible = false;
			submarineAttackButton.visible = false;
			sihaAttackButton.visible = false;
		} else if (sihaAttackInProgress) {
			statusText.setText('SİHA saldırısı devam ediyor...');
			turnText.setText('SİHA SALDIRISI');
			airBombardmentButton.visible = false;
			submarineAttackButton.visible = false;
			sihaAttackButton.visible = false;
		} else {
			var aiHasAttacks = aiAttackRights.air > 0 || aiAttackRights.submarine > 0 || aiAttackRights.siha > 0;
			var aiAttackText = aiHasAttacks && aiLastAttackType !== 'regular' ? ' (Özel saldırı hazırlanıyor...)' : '';
			statusText.setText('Düşman düşünüyor...' + aiAttackText);
			turnText.setText('DÜŞMAN SIRASI');
		}
	}
	updateAttackRightsDisplay();
}
function handleShipPlacement(row, col) {
	if (currentShipIndex >= shipSizes.length) return;
	var shipLength = shipSizes[currentShipIndex];
	var shipType = shipAssets[currentShipIndex];
	if (playerGrid.placeShip(row, col, shipLength, isHorizontal, shipType)) {
		currentShipIndex++;
		updateFleetStatus();
		if (currentShipIndex >= shipSizes.length) {
			// All ships placed, start AI placement
			placeAIShips();
			gamePhase = 'battle';
			rotateButton.visible = false;
			autoPlaceButton.visible = false;
			enemyGrid.visible = true;
			updateStatusText();
		} else {
			updateStatusText();
		}
	}
}
function autoPlacePlayerShips() {
	// Clear existing ships and their graphics
	for (var i = 0; i < playerGrid.ships.length; i++) {
		var ship = playerGrid.ships[i];
		if (ship.shipGraphic) {
			ship.shipGraphic.destroy();
			ship.shipGraphic = null;
		}
		for (var j = 0; j < ship.cells.length; j++) {
			var cellPos = ship.cells[j];
			playerGrid.cells[cellPos.row][cellPos.col].removeShip();
		}
	}
	playerGrid.ships = [];
	// Clear all hit and miss markers from the board
	for (var row = 0; row < gridSize; row++) {
		for (var col = 0; col < gridSize; col++) {
			var cell = playerGrid.cells[row][col];
			cell.isHit = false;
			cell.isMiss = false;
			// Remove any visual markers that might exist
			if (cell.hitMarker) {
				cell.hitMarker.destroy();
				cell.hitMarker = null;
			}
			if (cell.missMarker) {
				cell.missMarker.destroy();
				cell.missMarker = null;
			}
		}
	}
	// Reset ship placement index
	currentShipIndex = 0;
	var playerShipSizes = [5, 4, 3, 3, 2];
	var playerShipTypes = ['carrier', 'battleship', 'cruiser', 'cruiser', 'destroyer'];
	for (var i = 0; i < playerShipSizes.length; i++) {
		var placed = false;
		var attempts = 0;
		while (!placed && attempts < 100) {
			var row = Math.floor(Math.random() * gridSize);
			var col = Math.floor(Math.random() * gridSize);
			var horizontal = Math.random() < 0.5;
			if (playerGrid.placeShip(row, col, playerShipSizes[i], horizontal, playerShipTypes[i])) {
				placed = true;
				currentShipIndex++;
			}
			attempts++;
		}
	}
	// Update status text to show current placement state
	updateStatusText();
	updateFleetStatus();
}
function placeAIShips() {
	var aiShipSizes = [5, 4, 3, 3, 2];
	var aiShipTypes = ['carrier', 'battleship', 'cruiser', 'cruiser', 'destroyer'];
	for (var i = 0; i < aiShipSizes.length; i++) {
		var placed = false;
		var attempts = 0;
		while (!placed && attempts < 100) {
			var row = Math.floor(Math.random() * gridSize);
			var col = Math.floor(Math.random() * gridSize);
			var horizontal = Math.random() < 0.5;
			if (enemyGrid.placeShip(row, col, aiShipSizes[i], horizontal, aiShipTypes[i])) {
				placed = true;
			}
			attempts++;
		}
	}
}
updateFleetStatus();
function handlePlayerShot(row, col) {
	if (!playerTurn) return;
	lastAttackType = 'regular'; // Set last attack type for regular shots
	LK.getSound('shoot').play();
	var result = enemyGrid.checkHit(row, col);
	if (result === 'hit' || result === 'sunk') {
		LK.setScore(LK.getScore() + (result === 'sunk' ? 100 : 50));
		if (enemyGrid.allShipsSunk()) {
			gamePhase = 'gameOver';
			statusText.setText('Zafer! Tüm düşman gemileri yok edildi!');
			turnText.setText('KAZANDINIZ!');
			LK.showYouWin();
			return;
		}
	}
	playerTurn = false;
	airBombardmentButton.visible = false;
	submarineAttackButton.visible = false;
	sihaAttackButton.visible = false;
	updateStatusText();
	// AI turn after delay
	LK.setTimeout(function () {
		aiTurn();
	}, 1000);
}
function executeAirBombardment() {
	if (playerAttackRights.air <= 0 || airBombardmentInProgress) return;
	playerAttackRights.air--;
	airBombardmentInProgress = true;
	lastAttackType = 'air'; // Set last attack type
	playerTurn = false;
	crosshairActive = false;
	if (crosshairGraphic) {
		crosshairGraphic.visible = false;
	}
	updateAttackRightsDisplay();
	statusText.setText('Hava bombardımanı başlatıldı! Uçaklar hedefe yaklaşıyor...');
	turnText.setText('HAVA SALDIRISI');
	// Generate 5 random target positions
	var targets = [];
	var attempts = 0;
	while (targets.length < 5 && attempts < 100) {
		var row = Math.floor(Math.random() * gridSize);
		var col = Math.floor(Math.random() * gridSize);
		var duplicate = false;
		for (var i = 0; i < targets.length; i++) {
			if (targets[i].row === row && targets[i].col === col) {
				duplicate = true;
				break;
			}
		}
		if (!duplicate) {
			targets.push({
				row: row,
				col: col
			});
		}
		attempts++;
	}
	// Create aircraft animation
	var aircraft = game.attachAsset('missile', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: -100,
		y: 200,
		scaleX: 2,
		scaleY: 2,
		rotation: Math.PI / 4
	});
	// Animate aircraft flying across screen
	tween(aircraft, {
		x: 2148,
		y: 300
	}, {
		duration: 2000,
		easing: tween.linear,
		onFinish: function onFinish() {
			aircraft.destroy();
			// Execute bombardment hits with delays
			executeTargetHits(targets, 0);
		}
	});
}
function executeTargetHits(targets, currentIndex) {
	if (currentIndex >= targets.length) {
		// All hits completed
		LK.setTimeout(function () {
			airBombardmentInProgress = false;
			if (enemyGrid.allShipsSunk()) {
				gamePhase = 'gameOver';
				statusText.setText('Zafer! Tüm düşman gemileri yok edildi!');
				turnText.setText('KAZANDINIZ!');
				LK.showYouWin();
				return;
			}
			// AI turn after air bombardment
			aiLastAttackType = null; // Reset AI attack type to allow AI special attacks
			LK.setTimeout(function () {
				aiTurn();
			}, 1000);
		}, 1000);
		return;
	}
	var target = targets[currentIndex];
	// Create bomb falling animation
	var bomb = game.attachAsset('missile', {
		anchorX: 0.5,
		anchorY: 1,
		x: enemyGrid.x + target.col * 60 * 1.5 + 30 * 1.5,
		y: 100,
		alpha: 0.8
	});
	tween(bomb, {
		y: enemyGrid.y + target.row * 60 * 1.5 + 30 * 1.5,
		alpha: 0.3
	}, {
		duration: 600,
		onFinish: function onFinish() {
			bomb.destroy();
			// Check hit result
			var result = enemyGrid.checkHit(target.row, target.col);
			if (result === 'hit' || result === 'sunk') {
				LK.setScore(LK.getScore() + (result === 'sunk' ? 100 : 50));
			}
			// Continue with next target after short delay
			LK.setTimeout(function () {
				executeTargetHits(targets, currentIndex + 1);
			}, 300);
		}
	});
}
function executeSubmarineAttack() {
	if (playerAttackRights.submarine <= 0 || submarineAttackInProgress) return;
	playerAttackRights.submarine--;
	submarineAttackInProgress = true;
	lastAttackType = 'submarine'; // Set last attack type
	playerTurn = false;
	crosshairActive = false;
	if (crosshairGraphic) {
		crosshairGraphic.visible = false;
	}
	updateAttackRightsDisplay();
	statusText.setText('Denizaltı saldırısı başlatıldı! Torpido hazırlanıyor...');
	turnText.setText('DENİZALTI SALDIRISI');
	// Find all enemy ships that are not yet sunk
	var availableTargets = [];
	for (var i = 0; i < enemyGrid.ships.length; i++) {
		var ship = enemyGrid.ships[i];
		if (!ship.sunk) {
			// Add all unhit cells of this ship as potential targets
			for (var j = 0; j < ship.cells.length; j++) {
				var cellPos = ship.cells[j];
				var cell = enemyGrid.cells[cellPos.row][cellPos.col];
				if (!cell.isHit) {
					availableTargets.push({
						row: cellPos.row,
						col: cellPos.col
					});
				}
			}
		}
	}
	// If no available targets (all ships sunk or all remaining cells hit), just end
	if (availableTargets.length === 0) {
		submarineAttackInProgress = false;
		playerTurn = true;
		updateStatusText();
		return;
	}
	// Select random target from available unhit ship cells
	var target = availableTargets[Math.floor(Math.random() * availableTargets.length)];
	// Create submarine animation from bottom of screen
	var submarine = game.attachAsset('submarine', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: enemyGrid.x + target.col * 60 * 1.5 + 30 * 1.5,
		y: 2732 + 100,
		scaleX: 2,
		scaleY: 2,
		alpha: 0.7
	});
	// Animate submarine rising
	tween(submarine, {
		y: enemyGrid.y + target.row * 60 * 1.5 + 200,
		alpha: 1
	}, {
		duration: 1500,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			// Create torpedo
			var torpedo = game.attachAsset('missile', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: submarine.x,
				y: submarine.y,
				scaleX: 1.5,
				scaleY: 1.5,
				rotation: -Math.PI / 2,
				alpha: 0.9
			});
			// Animate torpedo to target
			tween(torpedo, {
				x: enemyGrid.x + target.col * 60 * 1.5 + 30 * 1.5,
				y: enemyGrid.y + target.row * 60 * 1.5 + 30 * 1.5,
				alpha: 0.5
			}, {
				duration: 800,
				easing: tween.linear,
				onFinish: function onFinish() {
					torpedo.destroy();
					// Guaranteed hit on ship
					var result = enemyGrid.checkHit(target.row, target.col);
					LK.setScore(LK.getScore() + (result === 'sunk' ? 150 : 75));
					// Submarine disappears
					tween(submarine, {
						y: 2732 + 100,
						alpha: 0
					}, {
						duration: 1000,
						easing: tween.easeIn,
						onFinish: function onFinish() {
							submarine.destroy();
							submarineAttackInProgress = false;
							if (enemyGrid.allShipsSunk()) {
								gamePhase = 'gameOver';
								statusText.setText('Zafer! Tüm düşman gemileri yok edildi!');
								turnText.setText('KAZANDINIZ!');
								LK.showYouWin();
								return;
							}
							// AI turn after submarine attack
							aiLastAttackType = null; // Reset AI attack type to allow AI special attacks
							LK.setTimeout(function () {
								aiTurn();
							}, 1000);
						}
					});
				}
			});
		}
	});
}
function executeSihaAttack() {
	if (playerAttackRights.siha <= 0 || sihaAttackInProgress) return;
	playerAttackRights.siha--;
	sihaAttackInProgress = true;
	lastAttackType = 'siha'; // Set last attack type
	playerTurn = false;
	crosshairActive = false;
	if (crosshairGraphic) {
		crosshairGraphic.visible = false;
	}
	updateAttackRightsDisplay();
	statusText.setText('SİHA saldırısı başlatıldı! Hedef aranıyor...');
	turnText.setText('SİHA SALDIRISI');
	// Find all enemy ships that are not yet sunk
	var availableShips = [];
	for (var i = 0; i < enemyGrid.ships.length; i++) {
		var ship = enemyGrid.ships[i];
		if (!ship.sunk) {
			availableShips.push(ship);
		}
	}
	// If no available ships, just end
	if (availableShips.length === 0) {
		sihaAttackInProgress = false;
		playerTurn = true;
		updateStatusText();
		return;
	}
	// Select random ship to completely destroy
	var targetShip = availableShips[Math.floor(Math.random() * availableShips.length)];
	var targetCells = [];
	// Get all cells of the target ship
	for (var j = 0; j < targetShip.cells.length; j++) {
		targetCells.push(targetShip.cells[j]);
	}
	// Create SIHA drone animation from top of screen
	var siha = game.attachAsset('missile', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: -100,
		y: -100,
		scaleX: 1.8,
		scaleY: 1.8,
		rotation: Math.PI / 6,
		alpha: 0.9
	});
	// Animate SIHA flying to target area
	var targetCenterX = enemyGrid.x + targetCells[0].col * 60 * 1.5 + 30 * 1.5;
	var targetCenterY = enemyGrid.y + targetCells[0].row * 60 * 1.5 + 30 * 1.5;
	tween(siha, {
		x: targetCenterX,
		y: targetCenterY - 150,
		rotation: 0
	}, {
		duration: 2500,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			// Hover for targeting
			tween(siha, {
				y: targetCenterY - 100,
				alpha: 1
			}, {
				duration: 800,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Execute precision strike - hit all cells of the ship
					executeShipDestruction(targetCells, 0, siha);
				}
			});
		}
	});
}
function executeShipDestruction(targetCells, currentIndex, siha) {
	if (currentIndex >= targetCells.length) {
		// All cells destroyed, SIHA returns
		tween(siha, {
			x: 2200,
			y: -100,
			alpha: 0.5
		}, {
			duration: 2000,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				siha.destroy();
				sihaAttackInProgress = false;
				if (enemyGrid.allShipsSunk()) {
					gamePhase = 'gameOver';
					statusText.setText('Zafer! Tüm düşman gemileri yok edildi!');
					turnText.setText('KAZANDINIZ!');
					LK.showYouWin();
					return;
				}
				// AI turn after SIHA attack
				aiLastAttackType = null; // Reset AI attack type to allow AI special attacks
				LK.setTimeout(function () {
					aiTurn();
				}, 1000);
			}
		});
		return;
	}
	var target = targetCells[currentIndex];
	// Create precision missile
	var missile = game.attachAsset('missile', {
		anchorX: 0.5,
		anchorY: 1,
		x: siha.x,
		y: siha.y,
		scaleX: 0.8,
		scaleY: 0.8,
		alpha: 0.9
	});
	tween(missile, {
		x: enemyGrid.x + target.col * 60 * 1.5 + 30 * 1.5,
		y: enemyGrid.y + target.row * 60 * 1.5 + 30 * 1.5,
		alpha: 0.4
	}, {
		duration: 400,
		easing: tween.linear,
		onFinish: function onFinish() {
			missile.destroy();
			// Guaranteed hit
			var result = enemyGrid.checkHit(target.row, target.col);
			if (result === 'hit' || result === 'sunk') {
				LK.setScore(LK.getScore() + (result === 'sunk' ? 200 : 100));
			}
			// Continue with next target after short delay
			LK.setTimeout(function () {
				executeShipDestruction(targetCells, currentIndex + 1, siha);
			}, 200);
		}
	});
}
function executeAIAirBombardment() {
	aiAttackRights.air--;
	aiLastAttackType = 'air';
	updateAttackRightsDisplay();
	statusText.setText('Düşman hava bombardımanı başlattı!');
	turnText.setText('DÜŞMAN HAVA SALDIRISI');
	// Generate 5 random target positions on player grid
	var targets = [];
	var attempts = 0;
	while (targets.length < 5 && attempts < 100) {
		var row = Math.floor(Math.random() * gridSize);
		var col = Math.floor(Math.random() * gridSize);
		var cell = playerGrid.cells[row][col];
		// Only target untouched cells
		if (!cell.isHit && !cell.isMiss) {
			var duplicate = false;
			for (var i = 0; i < targets.length; i++) {
				if (targets[i].row === row && targets[i].col === col) {
					duplicate = true;
					break;
				}
			}
			if (!duplicate) {
				targets.push({
					row: row,
					col: col
				});
			}
		}
		attempts++;
	}
	// Create AI aircraft animation
	var aircraft = game.attachAsset('missile', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2148,
		y: 200,
		scaleX: 2,
		scaleY: 2,
		rotation: -Math.PI * 3 / 4,
		tint: 0xFF0000
	});
	// Animate aircraft flying across screen
	tween(aircraft, {
		x: -100,
		y: 300
	}, {
		duration: 2000,
		easing: tween.linear,
		onFinish: function onFinish() {
			aircraft.destroy();
			executeAITargetHits(targets, 0);
		}
	});
}
function executeAITargetHits(targets, currentIndex) {
	if (currentIndex >= targets.length) {
		// All hits completed
		LK.setTimeout(function () {
			if (playerGrid.allShipsSunk()) {
				gamePhase = 'gameOver';
				statusText.setText('Yenilgi! Filonuz yok edildi!');
				turnText.setText('KAYBETTİNİZ!');
				LK.showGameOver();
				return;
			}
			playerTurn = true;
			lastAttackType = null;
			updateStatusText();
		}, 1000);
		return;
	}
	var target = targets[currentIndex];
	// Create bomb falling animation
	var bomb = game.attachAsset('missile', {
		anchorX: 0.5,
		anchorY: 1,
		x: playerGrid.x + target.col * 60 * 1.5 + 30 * 1.5,
		y: 100,
		alpha: 0.8,
		tint: 0xFF0000
	});
	tween(bomb, {
		y: playerGrid.y + target.row * 60 * 1.5 + 30 * 1.5,
		alpha: 0.3
	}, {
		duration: 600,
		onFinish: function onFinish() {
			bomb.destroy();
			var result = playerGrid.checkHit(target.row, target.col);
			LK.setTimeout(function () {
				executeAITargetHits(targets, currentIndex + 1);
			}, 300);
		}
	});
}
function executeAISubmarineAttack() {
	aiAttackRights.submarine--;
	aiLastAttackType = 'submarine';
	updateAttackRightsDisplay();
	statusText.setText('Düşman denizaltı saldırısı başlattı!');
	turnText.setText('DÜŞMAN DENİZALTI SALDIRISI');
	// Find player ships that are not yet sunk
	var availableTargets = [];
	for (var i = 0; i < playerGrid.ships.length; i++) {
		var ship = playerGrid.ships[i];
		if (!ship.sunk) {
			for (var j = 0; j < ship.cells.length; j++) {
				var cellPos = ship.cells[j];
				var cell = playerGrid.cells[cellPos.row][cellPos.col];
				if (!cell.isHit) {
					availableTargets.push({
						row: cellPos.row,
						col: cellPos.col
					});
				}
			}
		}
	}
	if (availableTargets.length === 0) {
		playerTurn = true;
		lastAttackType = null;
		updateStatusText();
		return;
	}
	// Select random target from available unhit ship cells
	var target = availableTargets[Math.floor(Math.random() * availableTargets.length)];
	// Create submarine animation
	var submarine = game.attachAsset('submarine', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: playerGrid.x + target.col * 60 * 1.5 + 30 * 1.5,
		y: 2732 + 100,
		scaleX: 2,
		scaleY: 2,
		alpha: 0.7,
		tint: 0xFF0000
	});
	// Animate submarine rising
	tween(submarine, {
		y: playerGrid.y + target.row * 60 * 1.5 + 200,
		alpha: 1
	}, {
		duration: 1500,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			// Create torpedo
			var torpedo = game.attachAsset('missile', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: submarine.x,
				y: submarine.y,
				scaleX: 1.5,
				scaleY: 1.5,
				rotation: -Math.PI / 2,
				alpha: 0.9,
				tint: 0xFF0000
			});
			// Animate torpedo to target
			tween(torpedo, {
				x: playerGrid.x + target.col * 60 * 1.5 + 30 * 1.5,
				y: playerGrid.y + target.row * 60 * 1.5 + 30 * 1.5,
				alpha: 0.5
			}, {
				duration: 800,
				easing: tween.linear,
				onFinish: function onFinish() {
					torpedo.destroy();
					var result = playerGrid.checkHit(target.row, target.col);
					// Submarine disappears
					tween(submarine, {
						y: 2732 + 100,
						alpha: 0
					}, {
						duration: 1000,
						easing: tween.easeIn,
						onFinish: function onFinish() {
							submarine.destroy();
							if (playerGrid.allShipsSunk()) {
								gamePhase = 'gameOver';
								statusText.setText('Yenilgi! Filonuz yok edildi!');
								turnText.setText('KAYBETTİNİZ!');
								LK.showGameOver();
								return;
							}
							playerTurn = true;
							lastAttackType = null;
							updateStatusText();
						}
					});
				}
			});
		}
	});
}
function executeAISihaAttack() {
	aiAttackRights.siha--;
	aiLastAttackType = 'siha';
	updateAttackRightsDisplay();
	statusText.setText('Düşman SİHA saldırısı başlattı!');
	turnText.setText('DÜŞMAN SİHA SALDIRISI');
	// Find all player ships that are not yet sunk
	var availableShips = [];
	for (var i = 0; i < playerGrid.ships.length; i++) {
		var ship = playerGrid.ships[i];
		if (!ship.sunk) {
			availableShips.push(ship);
		}
	}
	if (availableShips.length === 0) {
		playerTurn = true;
		lastAttackType = null;
		updateStatusText();
		return;
	}
	// Select random ship to completely destroy
	var targetShip = availableShips[Math.floor(Math.random() * availableShips.length)];
	var targetCells = [];
	for (var j = 0; j < targetShip.cells.length; j++) {
		targetCells.push(targetShip.cells[j]);
	}
	// Create AI SIHA drone animation
	var siha = game.attachAsset('missile', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2148,
		y: -100,
		scaleX: 1.8,
		scaleY: 1.8,
		rotation: -Math.PI / 6,
		alpha: 0.9,
		tint: 0xFF0000
	});
	// Animate SIHA flying to target area
	var targetCenterX = playerGrid.x + targetCells[0].col * 60 * 1.5 + 30 * 1.5;
	var targetCenterY = playerGrid.y + targetCells[0].row * 60 * 1.5 + 30 * 1.5;
	tween(siha, {
		x: targetCenterX,
		y: targetCenterY - 150,
		rotation: 0
	}, {
		duration: 2500,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(siha, {
				y: targetCenterY - 100,
				alpha: 1
			}, {
				duration: 800,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					executeAIShipDestruction(targetCells, 0, siha);
				}
			});
		}
	});
}
function executeAIShipDestruction(targetCells, currentIndex, siha) {
	if (currentIndex >= targetCells.length) {
		// All cells destroyed, SIHA returns
		tween(siha, {
			x: 2200,
			y: -100,
			alpha: 0.5
		}, {
			duration: 2000,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				siha.destroy();
				if (playerGrid.allShipsSunk()) {
					gamePhase = 'gameOver';
					statusText.setText('Yenilgi! Filonuz yok edildi!');
					turnText.setText('KAYBETTİNİZ!');
					LK.showGameOver();
					return;
				}
				playerTurn = true;
				lastAttackType = null;
				updateStatusText();
			}
		});
		return;
	}
	var target = targetCells[currentIndex];
	// Create precision missile
	var missile = game.attachAsset('missile', {
		anchorX: 0.5,
		anchorY: 1,
		x: siha.x,
		y: siha.y,
		scaleX: 0.8,
		scaleY: 0.8,
		alpha: 0.9,
		tint: 0xFF0000
	});
	tween(missile, {
		x: playerGrid.x + target.col * 60 * 1.5 + 30 * 1.5,
		y: playerGrid.y + target.row * 60 * 1.5 + 30 * 1.5,
		alpha: 0.4
	}, {
		duration: 400,
		easing: tween.linear,
		onFinish: function onFinish() {
			missile.destroy();
			var result = playerGrid.checkHit(target.row, target.col);
			LK.setTimeout(function () {
				executeAIShipDestruction(targetCells, currentIndex + 1, siha);
			}, 200);
		}
	});
}
function aiTurn() {
	// Check if AI should use a special attack (30% chance if available and not consecutive)
	var shouldUseSpecialAttack = Math.random() < 0.3;
	var availableAttacks = [];
	// Check which attacks are available (have rights remaining and not the last attack type)
	if (aiAttackRights.air > 0 && aiLastAttackType !== 'air') {
		availableAttacks.push('air');
	}
	if (aiAttackRights.submarine > 0 && aiLastAttackType !== 'submarine') {
		availableAttacks.push('submarine');
	}
	if (aiAttackRights.siha > 0 && aiLastAttackType !== 'siha') {
		availableAttacks.push('siha');
	}
	// Use special attack if conditions are met
	if (shouldUseSpecialAttack && availableAttacks.length > 0) {
		var selectedAttack = availableAttacks[Math.floor(Math.random() * availableAttacks.length)];
		if (selectedAttack === 'air') {
			executeAIAirBombardment();
			return;
		} else if (selectedAttack === 'submarine') {
			executeAISubmarineAttack();
			return;
		} else if (selectedAttack === 'siha') {
			executeAISihaAttack();
			return;
		}
	}
	// Regular attack logic
	var row, col;
	var attempts = 0;
	var targetFound = false;
	if (aiHuntMode && aiLastHit) {
		// First priority: Try adjacent cells to last hit
		var adjacents = [{
			row: aiLastHit.row - 1,
			col: aiLastHit.col
		}, {
			row: aiLastHit.row + 1,
			col: aiLastHit.col
		}, {
			row: aiLastHit.row,
			col: aiLastHit.col - 1
		}, {
			row: aiLastHit.row,
			col: aiLastHit.col + 1
		}];
		var validTargets = [];
		for (var i = 0; i < adjacents.length; i++) {
			var target = adjacents[i];
			if (target.row >= 0 && target.row < gridSize && target.col >= 0 && target.col < gridSize) {
				var cell = playerGrid.cells[target.row][target.col];
				if (!cell.isHit && !cell.isMiss) {
					validTargets.push(target);
				}
			}
		}
		if (validTargets.length > 0) {
			var chosen = validTargets[Math.floor(Math.random() * validTargets.length)];
			row = chosen.row;
			col = chosen.col;
			targetFound = true;
		} else {
			// Second priority: Look for any hit cells that still have adjacent untested cells
			var allHitCells = [];
			for (var r = 0; r < gridSize; r++) {
				for (var c = 0; c < gridSize; c++) {
					var cell = playerGrid.cells[r][c];
					if (cell.isHit && cell.hasShip) {
						// Check if this hit cell's ship is not sunk
						var shipNotSunk = false;
						for (var s = 0; s < playerGrid.ships.length; s++) {
							var ship = playerGrid.ships[s];
							if (!ship.sunk) {
								for (var sc = 0; sc < ship.cells.length; sc++) {
									if (ship.cells[sc].row === r && ship.cells[sc].col === c) {
										shipNotSunk = true;
										break;
									}
								}
							}
							if (shipNotSunk) break;
						}
						if (shipNotSunk) {
							allHitCells.push({
								row: r,
								col: c
							});
						}
					}
				}
			}
			// Find hit cells that still have adjacent untested targets
			var validHitCells = [];
			for (var h = 0; h < allHitCells.length; h++) {
				var hitCell = allHitCells[h];
				var hitAdjacents = [{
					row: hitCell.row - 1,
					col: hitCell.col
				}, {
					row: hitCell.row + 1,
					col: hitCell.col
				}, {
					row: hitCell.row,
					col: hitCell.col - 1
				}, {
					row: hitCell.row,
					col: hitCell.col + 1
				}];
				for (var ha = 0; ha < hitAdjacents.length; ha++) {
					var adj = hitAdjacents[ha];
					if (adj.row >= 0 && adj.row < gridSize && adj.col >= 0 && adj.col < gridSize) {
						var adjCell = playerGrid.cells[adj.row][adj.col];
						if (!adjCell.isHit && !adjCell.isMiss) {
							validHitCells.push(adj);
						}
					}
				}
			}
			if (validHitCells.length > 0) {
				var chosen = validHitCells[Math.floor(Math.random() * validHitCells.length)];
				row = chosen.row;
				col = chosen.col;
				targetFound = true;
			} else {
				aiHuntMode = false;
				aiLastHit = null;
			}
		}
	}
	if (!targetFound) {
		// Random targeting
		do {
			row = Math.floor(Math.random() * gridSize);
			col = Math.floor(Math.random() * gridSize);
			attempts++;
		} while ((playerGrid.cells[row][col].isHit || playerGrid.cells[row][col].isMiss) && attempts < 100);
	}
	var result = playerGrid.checkHit(row, col);
	if (result === 'hit' || result === 'sunk') {
		aiLastHit = {
			row: row,
			col: col
		};
		aiHuntMode = true;
		if (result === 'sunk') {
			aiHuntMode = false;
			aiLastHit = null;
		} else if (result === 'hit') {
			// Ship was hit but not sunk, continue attacking surrounding area
			LK.setTimeout(function () {
				aiTurn(); // Continue attacking immediately
			}, 1500);
			return;
		}
		if (playerGrid.allShipsSunk()) {
			gamePhase = 'gameOver';
			statusText.setText('Yenilgi! Filonuz yok edildi!');
			turnText.setText('KAYBETTİNİZ!');
			LK.showGameOver();
			return;
		}
	}
	playerTurn = true;
	lastAttackType = null; // Reset attack type after AI turn to allow alternating attacks
	aiLastAttackType = 'regular'; // Set AI's last attack as regular
	updateStatusText();
}
// Fleet status displays
var playerFleetStatus = new Container();
playerFleetStatus.x = 1700;
playerFleetStatus.y = 1500;
game.addChild(playerFleetStatus);
var enemyFleetStatus = new Container();
enemyFleetStatus.x = 1700;
enemyFleetStatus.y = 900;
game.addChild(enemyFleetStatus);
// Fleet status title texts
var playerFleetTitle = new Text2('Filonuz', {
	size: 40,
	fill: 0x66FF66
});
playerFleetTitle.anchor.set(0.5, 0);
playerFleetTitle.x = 0;
playerFleetTitle.y = -60;
playerFleetStatus.addChild(playerFleetTitle);
var enemyFleetTitle = new Text2('Düşman Filosu', {
	size: 40,
	fill: 0xFF6666
});
enemyFleetTitle.anchor.set(0.5, 0);
enemyFleetTitle.x = 0;
enemyFleetTitle.y = -60;
enemyFleetStatus.addChild(enemyFleetTitle);
// Fleet status arrays
var playerFleetDisplay = [];
var enemyFleetDisplay = [];
function updateFleetStatus() {
	// Initialize arrays if they don't exist
	if (!playerFleetDisplay) playerFleetDisplay = [];
	if (!enemyFleetDisplay) enemyFleetDisplay = [];
	// Clear existing displays
	for (var i = 0; i < playerFleetDisplay.length; i++) {
		playerFleetDisplay[i].destroy();
	}
	for (var i = 0; i < enemyFleetDisplay.length; i++) {
		enemyFleetDisplay[i].destroy();
	}
	playerFleetDisplay = [];
	enemyFleetDisplay = [];
	// Create player fleet status
	createFleetStatusDisplay(playerGrid, playerFleetStatus, playerFleetDisplay, true);
	// Create enemy fleet status  
	createFleetStatusDisplay(enemyGrid, enemyFleetStatus, enemyFleetDisplay, false);
}
function createFleetStatusDisplay(grid, statusContainer, displayArray, isPlayerFleet) {
	for (var i = 0; i < grid.ships.length; i++) {
		var ship = grid.ships[i];
		// Create main ship container
		var shipContainer = new Container();
		shipContainer.x = 0;
		shipContainer.y = i * 50; // Reduced spacing for text-only
		statusContainer.addChild(shipContainer);
		displayArray.push(shipContainer);
		// Create ship info display (text only)
		createShipTextDisplay(ship, shipContainer, i, isPlayerFleet);
	}
}
function createShipTextDisplay(ship, container, shipIndex, isPlayerFleet) {
	// Ship name and status
	var shipName = shipTypes[shipIndex];
	var statusText = shipName;
	var statusColor = 0xCCCCCC;
	// Determine status and color
	if (isPlayerFleet) {
		if (ship.sunk) {
			statusColor = 0xFF4444;
			statusText += ' - BATIK (' + ship.hits + '/' + ship.length + ')';
		} else if (ship.hits > 0) {
			statusColor = 0xFFAA00;
			statusText += ' - Hasarlı (' + ship.hits + '/' + ship.length + ')';
		} else {
			statusColor = 0x66FF99;
			statusText += ' - Sağlam (' + ship.hits + '/' + ship.length + ')';
		}
	} else {
		// Enemy fleet - only show detailed status if damaged or sunk
		if (ship.sunk) {
			statusColor = 0xFF4444;
			statusText += ' - BATIK (' + ship.hits + '/' + ship.length + ')';
		} else if (ship.hits > 0) {
			statusColor = 0xFFAA00;
			statusText += ' - Hasarlı (' + ship.hits + '/' + ship.length + ')';
		} else {
			statusColor = 0x888888;
			statusText += ' - Bilinmiyor';
		}
	}
	var nameText = new Text2(statusText, {
		size: 28,
		fill: statusColor
	});
	nameText.anchor.set(0, 0);
	nameText.x = 0;
	nameText.y = 0;
	container.addChild(nameText);
}
// Removed - no longer needed for text-only display
// Removed - no longer needed for text-only display
// Game info page variables
var gameInfoShown = false;
var currentInfoPage = 0;
var totalInfoPages = 3;
// Difficulty selection variables
var difficultySelected = false;
var selectedDifficulty = 'easy'; // default
var gridSize = 8; // will be updated based on difficulty
// Game information page UI
var gameInfoContainer = new Container();
gameInfoContainer.x = 2048 / 2;
gameInfoContainer.y = 2732 / 2;
game.addChild(gameInfoContainer);
// Info page background
var infoBg = LK.getAsset('water', {
	width: 1800,
	height: 2400,
	x: -900,
	y: -1200,
	color: 0x001122
});
infoBg.alpha = 0.95;
gameInfoContainer.addChild(infoBg);
// Info page title
var infoTitle = new Text2('AMİRAL BATTI', {
	size: 80,
	fill: 0xFFD700
});
infoTitle.anchor.set(0.5, 0.5);
infoTitle.x = 0;
infoTitle.y = -1000;
gameInfoContainer.addChild(infoTitle);
// Page indicator
var pageIndicator = new Text2('Sayfa 1 / 3', {
	size: 50,
	fill: 0xCCCCCC
});
pageIndicator.anchor.set(0.5, 0.5);
pageIndicator.x = 0;
pageIndicator.y = -900;
gameInfoContainer.addChild(pageIndicator);
// Info content container
var infoContentContainer = new Container();
infoContentContainer.x = 0;
infoContentContainer.y = -400;
gameInfoContainer.addChild(infoContentContainer);
// Navigation buttons
var prevButton = new Text2('← ÖNCEKİ', {
	size: 60,
	fill: 0x888888
});
prevButton.anchor.set(0.5, 0.5);
prevButton.x = -300;
prevButton.y = 1000;
gameInfoContainer.addChild(prevButton);
var nextButton = new Text2('SONRAKİ →', {
	size: 60,
	fill: 0x00FF00
});
nextButton.anchor.set(0.5, 0.5);
nextButton.x = 300;
nextButton.y = 1000;
gameInfoContainer.addChild(nextButton);
var startGameButton = new Text2('OYUNA BAŞLA', {
	size: 70,
	fill: 0xFF0000
});
startGameButton.anchor.set(0.5, 0.5);
startGameButton.x = 0;
startGameButton.y = 900;
startGameButton.visible = false;
gameInfoContainer.addChild(startGameButton);
// Info page content arrays
var infoPages = [
// Page 1: Basic Rules
['OYUN KURALLARI', '', '• Deniz savaşı oyununda amacınız düşman', '  filosunu tamamen yok etmektir', '', '• Filonuzda 5 farklı gemi türü bulunur:', '  - Uçak Gemisi (5 kare)', '  - Savaş Gemisi (4 kare)', '  - Kruvazör x2 (3 kare)', '  - Muhrip (2 kare)', '', '• Gemiler yatay veya dikey olarak', '  yerleştirilebilir', '', '• Düşman ızgarasına tıklayarak ateş edin', '• İsabet: Kırmızı, Kaçan: Mavi'],
// Page 2: Special Attacks
['ÖZEL SALDIRILAR', '', '🛩️ HAVA BOMBARDIMANI (2 Hak)', '• 5 rastgele hedefe eş zamanlı saldırı', '• Geniş alan hasarı', '• Ardışık kullanılamaz', '', '🚢 DENİZALTI SALDIRISI (2 Hak)', '• Düşman gemisine garantili isabet', '• Hedef otomatik seçilir', '• Yüksek hasar', '', '🛸 SİHA SALDIRISI (2 Hak)', '• Seçilen gemiyi tamamen yok eder', '• Hassas hedefleme', '• En güçlü saldırı türü'],
// Page 3: Game Tips
['OYUN İPUÇLARI', '', '⚡ STRATEJİ TAVSİYELERİ:', '', '• Gemilerinizi rastgele yerleştirin', '• Özel saldırıları akıllıca kullanın', '• Düşman vuruşlarından kalıp çıkarın', '• Isabet aldığınız bölgelerin etrafını', '  sistematik olarak tarayın', '', '🎯 ZORLUK SEVİYELERİ:', '• Kolay: Yavaş yapay zeka', '• Orta: Dengeli yapay zeka', '• Zor: Agresif yapay zeka', '', '• Düşman da özel saldırılara sahiptir!', '• Savunmanızı güçlü tutun!']];
// Button event handlers
prevButton.down = function (x, y, obj) {
	if (currentInfoPage > 0) {
		currentInfoPage--;
		updateInfoPage();
	}
};
nextButton.down = function (x, y, obj) {
	if (currentInfoPage < totalInfoPages - 1) {
		currentInfoPage++;
		updateInfoPage();
	}
};
startGameButton.down = function (x, y, obj) {
	gameInfoShown = true;
	gameInfoContainer.visible = false;
	difficultyContainer.visible = true;
};
function updateInfoPage() {
	// Clear existing content
	for (var i = infoContentContainer.children.length - 1; i >= 0; i--) {
		infoContentContainer.children[i].destroy();
	}
	// Update page indicator
	pageIndicator.setText('Sayfa ' + (currentInfoPage + 1) + ' / ' + totalInfoPages);
	// Add new content
	var content = infoPages[currentInfoPage];
	for (var i = 0; i < content.length; i++) {
		var line = content[i];
		var isTitle = i === 0;
		var isEmpty = line === '';
		if (!isEmpty) {
			var textSize = isTitle ? 80 : 55;
			var textColor = isTitle ? 0xFFD700 : line.startsWith('•') ? 0xCCCCCC : line.startsWith('🛩️') || line.startsWith('🚢') || line.startsWith('🛸') ? 0x00FFFF : line.startsWith('⚡') || line.startsWith('🎯') ? 0xFFAA00 : 0xFFFFFF;
			var lineText = new Text2(line, {
				size: textSize,
				fill: textColor
			});
			lineText.anchor.set(0.5, 0);
			lineText.x = 0;
			lineText.y = i * 60 - 200;
			infoContentContainer.addChild(lineText);
		}
	}
	// Update button visibility
	prevButton.visible = currentInfoPage > 0;
	prevButton.fill = currentInfoPage > 0 ? 0xFFFFFF : 0x888888;
	nextButton.visible = currentInfoPage < totalInfoPages - 1;
	nextButton.fill = currentInfoPage < totalInfoPages - 1 ? 0x00FF00 : 0x888888;
	startGameButton.visible = currentInfoPage === totalInfoPages - 1;
}
// Initialize first page
updateInfoPage();
// Difficulty selection UI
var difficultyContainer = new Container();
difficultyContainer.x = 2048 / 2;
difficultyContainer.y = 2732 / 2;
difficultyContainer.visible = false;
game.addChild(difficultyContainer);
var difficultyTitle = new Text2('Zorluk Seviyesi Seçin', {
	size: 80,
	fill: 0xFFFFFF
});
difficultyTitle.anchor.set(0.5, 0.5);
difficultyTitle.x = 0;
difficultyTitle.y = -200;
difficultyContainer.addChild(difficultyTitle);
// Easy button
var easyButton = new Text2('KOLAY (8x8)', {
	size: 65,
	fill: 0x00FF00
});
easyButton.anchor.set(0.5, 0.5);
easyButton.x = -400;
easyButton.y = 0;
difficultyContainer.addChild(easyButton);
easyButton.down = function (x, y, obj) {
	selectedDifficulty = 'easy';
	gridSize = 8;
	startGameWithDifficulty();
};
// Medium button
var mediumButton = new Text2('ORTA (8x8)', {
	size: 65,
	fill: 0xFFFF00
});
mediumButton.anchor.set(0.5, 0.5);
mediumButton.x = 0;
mediumButton.y = 0;
difficultyContainer.addChild(mediumButton);
mediumButton.down = function (x, y, obj) {
	selectedDifficulty = 'medium';
	gridSize = 8;
	startGameWithDifficulty();
};
// Hard button
var hardButton = new Text2('ZOR (8x8)', {
	size: 65,
	fill: 0xFF0000
});
hardButton.anchor.set(0.5, 0.5);
hardButton.x = 400;
hardButton.y = 0;
difficultyContainer.addChild(hardButton);
hardButton.down = function (x, y, obj) {
	selectedDifficulty = 'hard';
	gridSize = 8;
	startGameWithDifficulty();
};
function startGameWithDifficulty() {
	difficultySelected = true;
	difficultyContainer.visible = false;
	// Recreate grids with new size
	playerGrid.destroy();
	enemyGrid.destroy();
	playerGrid = new GameGrid(true);
	enemyGrid = new GameGrid(false);
	// Scale grids based on difficulty to fit screen - increased for closer view
	var baseScale = selectedDifficulty === 'easy' ? 2.0 : selectedDifficulty === 'medium' ? 1.8 : 1.5;
	playerGrid.scaleX = baseScale;
	playerGrid.scaleY = baseScale;
	enemyGrid.scaleX = baseScale;
	enemyGrid.scaleY = baseScale;
	// Center grids on screen
	var gridWidth = gridSize * 60 * baseScale;
	var screenCenterX = 2048 / 2;
	var gridCenterX = gridWidth / 2;
	playerGrid.x = screenCenterX - gridCenterX;
	playerGrid.y = 1400;
	enemyGrid.x = screenCenterX - gridCenterX;
	enemyGrid.y = 400;
	game.addChild(playerGrid);
	game.addChild(enemyGrid);
	// Hide enemy grid during placement phase
	enemyGrid.visible = false;
	// Update labels position
	enemyLabel.x = enemyGrid.x + gridSize * 60 * baseScale / 2;
	enemyLabel.y = enemyGrid.y - 60;
	playerLabel.x = playerGrid.x + gridSize * 60 * baseScale / 2;
	playerLabel.y = playerGrid.y - 60;
	// Add separator line between player and enemy grids
	var separatorLine = game.attachAsset('gridLine', {
		width: 2048,
		height: 4,
		x: 0,
		y: (enemyGrid.y + gridSize * 60 * baseScale + playerGrid.y) / 2,
		color: 0xFFFFFF
	});
	// Reset game state
	gamePhase = 'placement';
	currentShipIndex = 0;
	// Initial setup
	updateStatusText();
	updateAttackRightsDisplay();
}
// Hide all game elements initially
playerGrid.visible = false;
enemyGrid.visible = false;
statusText.visible = false;
turnText.visible = false;
enemyLabel.visible = false;
playerLabel.visible = false;
rotateButton.visible = false;
autoPlaceButton.visible = false;
startBattleButton.visible = false;
airBombardmentButton.visible = false;
submarineAttackButton.visible = false;
sihaAttackButton.visible = false;
attackRightsContainer.visible = false;
playerFleetStatus.visible = false;
enemyFleetStatus.visible = false;
shipPreviewContainer.visible = false;
activateCrosshairButton.visible = false;
crosshairControlsContainer.visible = false;
// Play background music from game start
LK.playMusic('deniz');
// Show info page initially
gameInfoContainer.visible = true;
game.update = function () {
	if (!gameInfoShown) {
		// Show info page
		gameInfoContainer.visible = true;
		difficultyContainer.visible = false;
	} else if (!difficultySelected) {
		// Show difficulty selection
		gameInfoContainer.visible = false;
		difficultyContainer.visible = true;
	} else if (difficultySelected) {
		// Show game elements once difficulty is selected
		gameInfoContainer.visible = false;
		difficultyContainer.visible = false;
		playerGrid.visible = true;
		enemyGrid.visible = gamePhase === 'battle';
		statusText.visible = true;
		turnText.visible = true;
		enemyLabel.visible = gamePhase === 'battle';
		playerLabel.visible = true;
		rotateButton.visible = gamePhase === 'placement';
		autoPlaceButton.visible = gamePhase === 'placement';
		startBattleButton.visible = gamePhase === 'placement' && currentShipIndex >= shipSizes.length;
		shipPreviewContainer.visible = gamePhase === 'placement' && currentShipIndex < shipSizes.length;
		playerFleetStatus.visible = true;
		enemyFleetStatus.visible = true;
	}
};

===================================================================
--- original.js
+++ change.js
@@ -944,44 +944,104 @@
 	}
 	// Create crosshair container for multiple elements
 	crosshairGraphic = new Container();
 	game.addChild(crosshairGraphic);
-	// Create outer targeting circle (cyan)
+	// Create grid alignment indicators
+	var alignmentIndicators = new Container();
+	crosshairGraphic.addChild(alignmentIndicators);
+	// Create horizontal grid alignment lines
+	for (var i = 0; i < gridSize + 1; i++) {
+		var hGridLine = alignmentIndicators.attachAsset('crosshairH', {
+			anchorX: 0.5,
+			anchorY: 0.5,
+			x: 0,
+			y: (i - gridSize / 2) * 60 * enemyGrid.scaleX,
+			width: gridSize * 60 * enemyGrid.scaleX,
+			height: 1,
+			alpha: 0.1,
+			color: 0x00FFFF
+		});
+	}
+	// Create vertical grid alignment lines  
+	for (var i = 0; i < gridSize + 1; i++) {
+		var vGridLine = alignmentIndicators.attachAsset('crosshairV', {
+			anchorX: 0.5,
+			anchorY: 0.5,
+			x: (i - gridSize / 2) * 60 * enemyGrid.scaleX,
+			y: 0,
+			width: 1,
+			height: gridSize * 60 * enemyGrid.scaleY,
+			alpha: 0.1,
+			color: 0x00FFFF
+		});
+	}
+	// Create outer targeting circle with dynamic sizing
 	var outerCircle = crosshairGraphic.attachAsset('crosshair', {
 		anchorX: 0.5,
 		anchorY: 0.5,
 		x: 0,
 		y: 0,
+		alpha: 0.4,
+		scaleX: 1.2,
+		scaleY: 1.2,
+		color: 0x00FFFF
+	});
+	// Create precision targeting square
+	var targetingSquare = crosshairGraphic.attachAsset('crosshair', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 0,
+		y: 0,
+		width: 60 * enemyGrid.scaleX,
+		height: 60 * enemyGrid.scaleY,
 		alpha: 0.3,
-		scaleX: 1.0,
-		scaleY: 1.0
+		color: 0xFFFF00
 	});
 	// Create horizontal crosshair line (red)
 	var hLine = crosshairGraphic.attachAsset('crosshairH', {
 		anchorX: 0.5,
 		anchorY: 0.5,
 		x: 0,
 		y: 0,
-		alpha: 0.9
+		alpha: 0.9,
+		width: 80,
+		height: 4
 	});
 	// Create vertical crosshair line (red)
 	var vLine = crosshairGraphic.attachAsset('crosshairV', {
 		anchorX: 0.5,
 		anchorY: 0.5,
 		x: 0,
 		y: 0,
-		alpha: 0.9
+		alpha: 0.9,
+		width: 4,
+		height: 80
 	});
 	// Create center dot for precise aiming
 	var centerDot = crosshairGraphic.attachAsset('crosshairV', {
 		anchorX: 0.5,
 		anchorY: 0.5,
 		x: 0,
 		y: 0,
-		width: 8,
-		height: 8,
-		alpha: 1.0
+		width: 10,
+		height: 10,
+		alpha: 1.0,
+		color: 0xFF0000
 	});
+	// Add coordinate display
+	var coordDisplay = new Text2('A1', {
+		size: 30,
+		fill: 0xFFFFFF
+	});
+	coordDisplay.anchor.set(0.5, 0.5);
+	coordDisplay.x = 0;
+	coordDisplay.y = -80;
+	crosshairGraphic.addChild(coordDisplay);
+	// Store references for animations
+	crosshairGraphic.outerCircle = outerCircle;
+	crosshairGraphic.targetingSquare = targetingSquare;
+	crosshairGraphic.coordDisplay = coordDisplay;
+	crosshairGraphic.alignmentIndicators = alignmentIndicators;
 	// Add touch-responsive functionality to crosshair
 	crosshairGraphic.down = function (x, y, obj) {
 		if (crosshairActive && gamePhase === 'battle' && playerTurn) {
 			// Convert touch position to grid coordinates
@@ -1017,12 +1077,23 @@
 		}
 	};
 	// Add pulsing animation to make crosshair more visible
 	tween(outerCircle, {
-		scaleX: 1.2,
-		scaleY: 1.2,
+		scaleX: 1.4,
+		scaleY: 1.4,
 		alpha: 0.6
 	}, {
+		duration: 1200,
+		easing: tween.easeInOut,
+		loop: true,
+		reverse: true
+	});
+	// Add targeting square pulse
+	tween(targetingSquare, {
+		alpha: 0.6,
+		scaleX: 1.1,
+		scaleY: 1.1
+	}, {
 		duration: 800,
 		easing: tween.easeInOut,
 		loop: true,
 		reverse: true
@@ -1034,15 +1105,71 @@
 		var cellSize = 60;
 		var scale = enemyGrid.scaleX;
 		var targetX = enemyGrid.x + (crosshairCol * cellSize + cellSize / 2) * scale;
 		var targetY = enemyGrid.y + (crosshairRow * cellSize + cellSize / 2) * scale;
-		// Smooth movement animation for better UX
+		// Update coordinate display (A1, B2, etc.)
+		var coordText = String.fromCharCode(65 + crosshairCol) + (crosshairRow + 1);
+		if (crosshairGraphic.coordDisplay) {
+			crosshairGraphic.coordDisplay.setText(coordText);
+		}
+		// Check if target cell is already hit/miss for visual feedback
+		var targetCell = enemyGrid.cells[crosshairRow][crosshairCol];
+		var isValidTarget = !targetCell.isHit && !targetCell.isMiss;
+		// Update targeting square color based on validity
+		if (crosshairGraphic.targetingSquare) {
+			var targetColor = isValidTarget ? 0x00FF00 : 0xFF0000;
+			crosshairGraphic.targetingSquare.tint = targetColor;
+			crosshairGraphic.targetingSquare.alpha = isValidTarget ? 0.4 : 0.2;
+		}
+		// Update crosshair color for feedback
+		if (crosshairGraphic.outerCircle) {
+			crosshairGraphic.outerCircle.tint = isValidTarget ? 0x00FFFF : 0xFF6666;
+		}
+		// Enhanced smooth movement animation with grid snapping
 		tween(crosshairGraphic, {
 			x: targetX,
 			y: targetY
 		}, {
-			duration: 150,
-			easing: tween.easeOut
+			duration: 200,
+			easing: tween.easeOutQuad,
+			onUpdate: function onUpdate() {
+				// Add subtle grid snapping feedback
+				if (crosshairGraphic.alignmentIndicators) {
+					crosshairGraphic.alignmentIndicators.alpha = 0.3;
+				}
+			},
+			onFinish: function onFinish() {
+				// Fade out alignment indicators
+				if (crosshairGraphic.alignmentIndicators) {
+					tween(crosshairGraphic.alignmentIndicators, {
+						alpha: 0.1
+					}, {
+						duration: 300,
+						easing: tween.easeOut
+					});
+				}
+				// Add confirmation pulse for valid targets
+				if (isValidTarget && crosshairGraphic.targetingSquare) {
+					tween(crosshairGraphic.targetingSquare, {
+						scaleX: 1.3,
+						scaleY: 1.3,
+						alpha: 0.7
+					}, {
+						duration: 150,
+						easing: tween.easeOut,
+						onFinish: function onFinish() {
+							tween(crosshairGraphic.targetingSquare, {
+								scaleX: 1.0,
+								scaleY: 1.0,
+								alpha: 0.4
+							}, {
+								duration: 150,
+								easing: tween.easeIn
+							});
+						}
+					});
+				}
+			}
 		});
 	}
 }
 function moveCrosshair(deltaRow, deltaCol) {
@@ -1052,8 +1179,38 @@
 		// Keep crosshair within grid bounds
 		if (newRow >= 0 && newRow < gridSize && newCol >= 0 && newCol < gridSize) {
 			crosshairRow = newRow;
 			crosshairCol = newCol;
+			// Add directional movement feedback
+			if (crosshairGraphic) {
+				// Create movement indicator
+				var direction = '';
+				if (deltaRow < 0) direction = '↑';else if (deltaRow > 0) direction = '↓';else if (deltaCol < 0) direction = '←';else if (deltaCol > 0) direction = '→';
+				if (direction) {
+					var moveIndicator = new Text2(direction, {
+						size: 40,
+						fill: 0x00FFFF
+					});
+					moveIndicator.anchor.set(0.5, 0.5);
+					moveIndicator.x = crosshairGraphic.x + deltaCol * 30;
+					moveIndicator.y = crosshairGraphic.y + deltaRow * 30;
+					moveIndicator.alpha = 0.8;
+					game.addChild(moveIndicator);
+					// Animate and remove indicator
+					tween(moveIndicator, {
+						alpha: 0,
+						scaleX: 1.5,
+						scaleY: 1.5,
+						y: moveIndicator.y + deltaRow * 20
+					}, {
+						duration: 400,
+						easing: tween.easeOut,
+						onFinish: function onFinish() {
+							moveIndicator.destroy();
+						}
+					});
+				}
+			}
 			updateCrosshairPosition();
 		}
 	}
 }