Final Version

Author: fz-zsl

.gitignore

@@ -0,0 +1,38 @@
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

.idea/.gitignore

@@ -0,0 +1,22 @@
+zsl,test,2,1,0
+zsl,test,3,4,0
+zsl,test,4,7,0
+zsl,test,5,10,0
+admin,zsl,6,13,0
+admin,zsl,7,16,0
+admin,zsl,8,19,0
+admin,zsl,9,22,0
+admin,root,10,25,0
+admin,root,11,28,0
+zsl,root,12,31,0
+admin,root,13,34,0
+zsl,root,14,36,1
+2,1,14,20,1
+2,1,4,2,0
+6,5,2,4,1
+2,1,2,2,0
+B,A,0,2,0
+D,C,2,2,0
+1,2,-4,8,0
+1,2,8,22,1
+4,3,0,6,0

.idea/checkstyle-idea.xml

@@ -0,0 +1,23 @@
+zsl,10,24
+test,12,30
+root,60,66
+admin,23,90
+1,0,0
+2,0,0
+3,0,0
+4,0,0
+5,0,0
+6,0,0
+e,0,0
+f,0,0
+A,0,0
+B,0,0
+C,0,0
+D,0,0
+E,0,0
+F,0,0
+G,0,0
+H,0,0
+P,0,0
+Q,0,0
+aefeef,0,0

.idea/encodings.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.example</groupId>
+    <artifactId>Linking-Game-Server</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>23</maven.compiler.source>
+        <maven.compiler.target>23</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>

.idea/material_theme_project_new.xml

@@ -0,0 +1,142 @@
+import java.io.*;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.Optional;
+
+public class Board implements Serializable {
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    public static final int EMPTY = -1;
+
+    public int row;
+    public int col;
+    public int[][] content;
+
+    public Board(int row, int col, int[][] content) {
+        this.row = row;
+        this.col = col;
+        this.content = content;
+    }
+
+    public void setBoard(int row, int col, int val) {
+        content[row][col] = val;
+    }
+
+    public void setBoard(int row, int col) {
+        setBoard(row, col, EMPTY);
+    }
+
+    public Optional<ArrayList<Position>> judge(int row1, int col1, int row2, int col2) {
+        if ((content[row1][col1] != content[row2][col2]) || (row1 == row2 && col1 == col2)) {
+            return Optional.empty();
+        }
+
+        // one line
+        if (isDirectlyConnected(row1, col1, row2, col2, content)) {
+            ArrayList<Position> res = new ArrayList<>();
+            res.add(new Position(row1, col1));
+            res.add(new Position(row2, col2));
+            return Optional.of(res);
+        }
+
+        // two lines
+        if ((row1 != row2) && (col1 != col2)) {
+            if (content[row1][col2] == EMPTY && isDirectlyConnected(row1, col1, row1, col2, content)
+                    && isDirectlyConnected(row1, col2, row2, col2, content)) {
+                ArrayList<Position> res = new ArrayList<>();
+                res.add(new Position(row1, col1));
+                res.add(new Position(row1, col2));
+                res.add(new Position(row2, col2));
+                return Optional.of(res);
+            }
+
+            if (content[row2][col1] == EMPTY && isDirectlyConnected(row2, col2, row2, col1, content)
+                    && isDirectlyConnected(row2, col1, row1, col1, content)) {
+                ArrayList<Position> res = new ArrayList<>();
+                res.add(new Position(row1, col1));
+                res.add(new Position(row2, col1));
+                res.add(new Position(row2, col2));
+                return Optional.of(res);
+            }
+        }
+
+        // three lines
+        if(row1 != row2) {
+            for (int i = 0; i < content[0].length; i++) {
+                if (content[row1][i] == EMPTY && content[row2][i] == EMPTY &&
+                        isDirectlyConnected(row1, col1, row1, i, content) &&
+                        isDirectlyConnected(row1, i, row2, i, content) &&
+                        isDirectlyConnected(row2, col2, row2, i, content)) {
+                    ArrayList<Position> res = new ArrayList<>();
+                    res.add(new Position(row1, col1));
+                    res.add(new Position(row1, i));
+                    res.add(new Position(row2, i));
+                    res.add(new Position(row2, col2));
+                    return Optional.of(res);
+                }
+            }
+        }
+        if(col1 != col2) {
+            for (int j = 0; j < content.length; j++) {
+                if (content[j][col1] == EMPTY && content[j][col2] == EMPTY &&
+                        isDirectlyConnected(row1, col1, j, col1, content) &&
+                        isDirectlyConnected(j, col1, j, col2, content) &&
+                        isDirectlyConnected(row2, col2, j, col2, content)) {
+                    ArrayList<Position> res = new ArrayList<>();
+                    res.add(new Position(row1, col1));
+                    res.add(new Position(j, col1));
+                    res.add(new Position(j, col2));
+                    res.add(new Position(row2, col2));
+                    return Optional.of(res);
+                }
+            }
+        }
+
+        return Optional.empty();
+    }
+
+    // judge whether
+    private boolean isDirectlyConnected(int row1, int col1, int row2, int col2, int[][] board) {
+        if (row1 == row2) {
+            int minCol = Math.min(col1, col2);
+            int maxCol = Math.max(col1, col2);
+            for (int col = minCol + 1; col < maxCol; col++) {
+                if (board[row1][col] != EMPTY) {
+                    return false;
+                }
+            }
+            return true;
+        } else if (col1 == col2) {
+            int minRow = Math.min(row1, row2);
+            int maxRow = Math.max(row1, row2);
+            for (int row = minRow + 1; row < maxRow; row++) {
+                if (board[row][col1] != EMPTY) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public boolean hasMoreMoves() {
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                if (content[i][j] != EMPTY) {
+                    for (int k = 0; k < row; k++) {
+                        for (int l = 0; l < col; l++) {
+                            if (i == k && j == l || content[k][l] == EMPTY) {
+                                continue;
+                            }
+                            if (content[i][j] == content[k][l] && judge(i, j, k, l).isPresent()) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}

.idea/misc.xml

@@ -0,0 +1,38 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Game {
+    public Player player0,  player1;
+    public Board board;
+    public final int NUM_ICONS = 12;
+
+    public Game(Player player0, Player player1, int row, int col) {
+        this.player0 = player0;
+        this.player1 = player1;
+        List<Integer> numbers = new ArrayList<>();
+
+        int avg = (row * col + NUM_ICONS - 1) / NUM_ICONS;
+        avg += (avg & 1);
+        for (int i = 0; i < NUM_ICONS; i++) {
+            for (int j = 0; j < avg; j++) {
+                numbers.add(i);
+            }
+        }
+        while (numbers.size() > row * col) {
+            numbers.removeLast();
+        }
+
+        do {
+            Collections.shuffle(numbers);
+            int[][] boardContent = new int[row][col];
+            int index = 0;
+            for (int i = 0; i < row; i++) {
+                for (int j = 0; j < col; j++) {
+                    boardContent[i][j] = numbers.get(index++);
+                }
+            }
+            board = new Board(row, col, boardContent);
+        } while (!board.hasMoreMoves());
+    }
+}