Hex — 03: חיבור מנצח

     <string name="board_description">Seven by seven Hex board</string>
     <string name="status_red_turn">Red to move</string>
     <string name="status_blue_turn">Blue to move</string>
+    <string name="status_red_wins">Red wins — top connected to bottom</string>
+    <string name="status_blue_wins">Blue wins — left connected to right</string>
 </resources>

 package com.example.hex;
 
+import java.util.ArrayDeque;
 import java.util.Arrays;
 
 /**
  * Stores a square Hex position and its game rules.

     public static final int RED = 1;
     /** Player value for Blue, whose goal is to connect left to right. */
     public static final int BLUE = 2;
 
+    private static final int[][] NEIGHBORS = {
+            {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}
+    };
+
     private final int size;
     private final int[] cells;
     private int currentPlayer;
+    private int winner = EMPTY;
 
     /**
      * Places the current player's stone and advances the turn when the move is legal.
      *

         if (cells[index] != EMPTY) {
             return false;
         }
 
         cells[index] = currentPlayer;
+        if (hasConnection(currentPlayer)) {
+            winner = currentPlayer;
+        }
+        // Advance the turn even after the winning move.
         currentPlayer = otherPlayer(currentPlayer);
         return true;
     }
 
+    /**
+     * Detects a win by searching the player's connected stones between both goal edges.
+     * <p>TWIN-ID: HEX.WIN_CHECK
+     *
+     * This check reads the board without placing a stone or changing the game state.
+     *
+     * @param player {@link #RED} (top to bottom) or {@link #BLUE} (left to right)
+     * @return {@code true} if the player's stones connect their two goal edges
+     */
+    public boolean hasConnection(int player) {
+
+        // Mark cells when queued so each stone is examined at most once.
+        boolean[] visited = new boolean[cells.length];
+        // Breadth-first search: cells waiting to be examined.
+        ArrayDeque<Integer> frontier = new ArrayDeque<>();
+        // Seed every stone on the player's starting edge.
+        for (int i = 0; i < size; i++) {
+            // Red starts on row 0; Blue starts on column 0.
+            int row = player == RED ? 0 : i;
+            int column = player == RED ? i : 0;
+            int start = index(row, column);
+            // Empty and opposing cells cannot begin this player's path.
+            if (cells[start] == player) {
+                visited[start] = true;
+                frontier.add(start);
+            }
+        }
+
+        // Expand the connected region until it reaches the goal or runs out.
+        while (!frontier.isEmpty()) {
+            int position = frontier.removeFirst();
+            // Convert the one-dimensional cell index back to board coordinates.
+            int row = position / size;
+            int column = position % size;
+            // The opposite edge completes Red's vertical or Blue's horizontal path.
+            if ((player == RED && row == size - 1)
+                    || (player == BLUE && column == size - 1)) {
+                return true;
+            }
+            // Follow only the six neighboring cells on the Hex grid.
+            for (int[] offset : NEIGHBORS) {
+                int nextRow = row + offset[0];
+                int nextColumn = column + offset[1];
+                // Ignore coordinates outside the board before computing an index.
+                if (isOutside(nextRow, nextColumn)) {
+                    continue;
+                }
+                int next = index(nextRow, nextColumn);
+                // An unvisited stone of this color extends the connected path.
+                if (!visited[next] && cells[next] == player) {
+                    visited[next] = true;
+                    frontier.addLast(next);
+                }
+            }
+        }
+        // Every reachable stone was checked without finding the goal edge.
+        return false;
+    }
+
+    /** @return the winning player, or {@link #EMPTY} while no player has won */
+    public int getWinner() {
+        return winner;
+    }
+
+    /** @return {@code true} after either player has completed a connection */
+    public boolean isOver() {
+        return winner != EMPTY;
+    }
+
     /**
      * Returns the value stored at one board coordinate.

 
-    /** Updates the board and status text from the current game state. */
+    /** Updates the board, available controls, and status text from the current state. */
     private void render() {
         binding.boardView.setGame(game);
-        binding.statusText.setText(game.getCurrentPlayer() == HexGame.RED
-                ? R.string.status_red_turn : R.string.status_blue_turn);
+        binding.boardView.setEnabled(!game.isOver());
+        if (game.getWinner() == HexGame.RED) {
+            binding.statusText.setText(R.string.status_red_wins);
+        } else if (game.getWinner() == HexGame.BLUE) {
+            binding.statusText.setText(R.string.status_blue_wins);
+        } else {
+            binding.statusText.setText(game.getCurrentPlayer() == HexGame.RED
+                    ? R.string.status_red_turn : R.string.status_blue_turn);
+        }
     }
 }