Проверка количества смежных плиток, принадлежащих игроку, и подсчет очков

По сути, вы собираетесь использовать алгоритм связанных компонентов. На входе у вас будет таблица истинности 9x9 для одного из цветов.

static Map<Integer, List<int[]>> cluster( boolean[][] occupied )

Это двухпроходный алгоритм компонента соединения. Первый проход проходим и делаем предварительные метки, так же создаем «касательный» список, который отслеживает соседние друг с другом регионы.

    int n = occupied.length;
    int[][] label = new int[n][n];
    int last = 1;
    List<int[]> touching = new ArrayList<>();

    //first pass
    for(int i = 0; i<n; i++){
        for(int j = 0; j<n; j++){
            if (occupied[i][j]){
                //4 way connectivity.
                int north = 0;
                int west = 0;
                int next = 0;
                if ( i > 0 && occupied[i-1][j]){
                    west = label[i-1][j];
                }
                if ( j > 0 && occupied[i][j-1]){
                    north = label[i][j-1];
                }
                if (west != 0){
                    if (north != 0){
                        //two labelled regions.
                        if (north == west){
                            //they're the same, it's ok.
                            next = north;
                        } else if (north < west){
                            //label it with the minimum one
                            next = north;
                            touching.add( new int[]{west, north} );
                        } else{
                            next = west;
                            touching.add( new int[]{north, west} );
                        }
                    } else{
                        next = west;
                    }
                } else if ( north != 0 ){
                    next = north;
                } else{
                    next = last++;
                }
                label[i][j] = next; //assign the label.
            } else{
                //not occupied.
                continue;
            }
        }
    }

Это первый проход, в конце первого прохода области помечаются, но есть соприкасающиеся области, которые нужно объединить. Это можно сделать со списком touching, но его нужно немного доработать.

На этом первом шаге все соприкасающиеся метки объединяются в связанные кластеры.

    List<TreeSet<Integer>> clusters = new ArrayList<>();
    
    for(int[] pair: touching){
        TreeSet<Integer> pair0 = null;
        TreeSet<Integer> pair1 = null;
        for(TreeSet<Integer> cluster: clusters){
            if (cluster.contains(pair[0])){
                pair0 = cluster;
            }
            if (cluster.contains(pair[1])){
                pair1 = cluster;
            }
        }
        if ( pair0 == null && pair1 == null){
            //new cluster
            TreeSet<Integer> newCluster = new TreeSet<>();
            newCluster.add(pair[0]);
            newCluster.add(pair[1]);
            clusters.add(newCluster);
        } else if ( pair0 == null ){
            pair1.add(pair[0]);
        } else if ( pair1 == null ){
            pair0.add(pair[1]);
        } else{
            if (pair0 == pair1) continue;
            //both labels are already in clusters but different clusters.
            pair0.addAll(pair1);
            clusters.remove(pair1);
        }
    }

Это проходит и создает сопоставление, так что все значения в кластере будут сопоставлены с наименьшим значением.

    Map<Integer, Integer> fin = new HashMap<>();
    for( TreeSet<Integer> cluster: clusters){
        Integer low = cluster.first();
        for(Integer i: cluster){
            fin.put(i, low);
        }
    }

Второй проход — это просто вопрос связывания меток с их ключами.

    Map<Integer, List<int[]>> result = new HashMap<>();
    //second pass
    for(int i = 0; i<n; i++){
        for(int j = 0; j<n; j++){
            if ( occupied[i][j] ){
                Integer f = fin.computeIfAbsent( label[i][j], k -> k );
                result.computeIfAbsent( f, k -> new ArrayList<>() ).add( new int[]{i, j} );
                label[i][j] = f;
            }
        }
    }

Результат будет содержать метку и набор int[], которые представляют все точки. Чтобы использовать это.

Map<Integer, List<int[]>> whiteClusters = cluster(occupiedWhite);
Map<Integer, List<int[]>> redClusters = cluster(occupiedRed);

Для полноты вот компилируемая рабочая версия.

import java.util.*;

public class ConnComp{
    static void printArray(int[][] arr){
        for(int[] row: arr){
            for(int i: row){
                System.out.printf("%3d",i);
            }
            System.out.println();
        }
    }
    
    static void printArray(boolean[][] arr){
        for(boolean[] row: arr){
            for(boolean i: row){
                System.out.print(i ? "  t" : "  f");
            }
            System.out.println();
        }
    }
    
    static Map<Integer, List<int[]>> cluster( boolean[][] occupied ){
        int n = occupied.length;
        int[][] label = new int[n][n];
        int last = 1;
        List<int[]> touching = new ArrayList<>();

        //first pass
        for(int i = 0; i<n; i++){
            for(int j = 0; j<n; j++){
                if (occupied[i][j]){
                    //4 way connectivity.
                    int north = 0;
                    int west = 0;
                    int next = 0;
                    if ( i > 0 && occupied[i-1][j]){
                        west = label[i-1][j];
                    }
                    if ( j > 0 && occupied[i][j-1]){
                        north = label[i][j-1];
                    }
                    if (west != 0){
                        if (north != 0){
                            //two labelled regions.
                            if (north == west){
                                //they're the same, it's ok.
                                next = north;
                            } else if (north < west){
                                //label it with the minimum one
                                next = north;
                                touching.add( new int[]{west, north} );
                            } else{
                                next = west;
                                touching.add( new int[]{north, west} );
                            }
                        } else{
                            next = west;
                        }
                    } else if ( north != 0 ){
                        next = north;
                    } else{
                        next = last++;
                    }
                    label[i][j] = next; //assign the label.
                } else{
                    //not occupied.
                    continue;
                }
            }
        }
        
        //map reduce
        Comparator<int[]> c = Comparator.comparingInt( arr -> arr[0] );
        Comparator<int[]> c2 = Comparator.comparingInt( arr -> arr[1] );
        c = c.thenComparing(c2);
        
        touching.sort( c );
        List<TreeSet<Integer>> clusters = new ArrayList<>();
        
        for(int[] pair: touching){
            TreeSet<Integer> pair0 = null;
            TreeSet<Integer> pair1 = null;
            for(TreeSet<Integer> cluster: clusters){
                if (cluster.contains(pair[0])){
                    pair0 = cluster;
                }
                if (cluster.contains(pair[1])){
                    pair1 = cluster;
                }
            }
            if ( pair0 == null && pair1 == null){
                //new cluster
                TreeSet<Integer> newCluster = new TreeSet<>();
                newCluster.add(pair[0]);
                newCluster.add(pair[1]);
                clusters.add(newCluster);
            } else if ( pair0 == null ){
                pair1.add(pair[0]);
            } else if ( pair1 == null ){
                pair0.add(pair[1]);
            } else{
                if (pair0 == pair1) continue;
                //both labels are already in clusters but different clusters.
                pair0.addAll(pair1);
                clusters.remove(pair1);
            }
        }
        
        Map<Integer, Integer> fin = new HashMap<>();
        for( TreeSet<Integer> cluster: clusters){
            Integer low = cluster.first();
            for(Integer i: cluster){
                fin.put(i, low);
            }
        }
        
        
        
        System.out.println("occupied");
        printArray(occupied);
        System.out.println("labelled");
        printArray(label);
        
        Map<Integer, List<int[]>> result = new HashMap<>();
        //second pass
        for(int i = 0; i<n; i++){
            for(int j = 0; j<n; j++){
                if ( occupied[i][j] ){
                    Integer f = fin.computeIfAbsent( label[i][j], k -> k );
                    result.computeIfAbsent( f, k -> new ArrayList<>() ).add( new int[]{i, j} );
                    label[i][j] = f;
                }
            }
        }
        System.out.println("after labelling");
        
        printArray(label);        
        
        return result;
    }
    
    static Random r = new Random(42);
    static boolean[][] getBoard(){
        int n = 9;
        boolean[][] board = new boolean[n][n];
        for(int i = 0; i<50; i++){
            int x = r.nextInt(n);
            int y = r.nextInt(n);
            board[x][y] = true;
        }
        return board;
    }
    
    public static void main(String[] args){
        
        cluster(getBoard());
        cluster(getBoard());
        
    }
}