server side bugfixes, add pass button

h908714124 · h908714124 · commit cc96ce2566e1 · 2024-07-20T13:11:48.000+02:00
diff --git a/Makefile b/Makefile
@@ -10,6 +10,9 @@ pack:
 lint:
 	cd src/main/client && npm run lint
 
+test:
+	./gradlew test
+
 run:
 	./gradlew bootRun
 
diff --git a/src/main/client/src/Play.jsx b/src/main/client/src/Play.jsx
@@ -37,7 +37,7 @@ export const Play = () => {
   let black = useGameStore(state => state.black)
   let white = useGameStore(state => state.white)
   let board = useGameStore(state => state.gameState.board)
-  let currentUser = useGameStore(state => state.gameState.currentUser)
+  let currentPlayer = useGameStore(state => state.gameState.currentPlayer)
   let initialized = useRef()
   let opponent = auth.name === black.name ? white : black
   useEffect(() => {
@@ -59,6 +59,15 @@ export const Play = () => {
       sub1.unsubscribe
     }
   }, [setGameState, initialized, stompClient, auth, gameId])
+  let onPass = useCallback(() => {
+    stompClient.publish({
+      destination: "/app/game/move",
+      body: JSON.stringify({
+        id: gameId,
+        pass: true,
+      }),
+    })
+  }, [stompClient, gameId])
   let onClick = useCallback((x, y) => {
     stompClient.publish({
       destination: "/app/game/move",
@@ -89,7 +98,7 @@ export const Play = () => {
             board.map((row, y) => (
               row.map((check, x) => (
                 <Tile
-                  disabled={currentUser !== auth.name}
+                  disabled={currentPlayer !== auth.name}
                   key={y + "_" + x}
                   onClick={() => onClick(x, y)}
                   check={check} />
@@ -99,12 +108,22 @@ export const Play = () => {
         </div>
       </div>
       <div className="fixed right-12 ml-4">
+      <div>
+        <button
+          onClick={onPass}
+          type="button"
+          className="bg-slate-700 hover:bg-slate-600 text-white px-2 py-1 rounded-lg">
+          Pass
+        </button>
+      </div>
+      <div className="mt-2">
       {
-        currentUser === auth.name ? 
+        currentPlayer === auth.name ?
           "Jetzt bin ich dran" : 
           (opponent.name + " ist dran...")
       }
       </div>
+      </div>
     </div>
   )
 }
diff --git a/src/main/client/src/store.js b/src/main/client/src/store.js
@@ -38,7 +38,7 @@ export const useGameStore = create((set, get) => ({
     name: "",
   },
   gameState: {
-    currentUser: undefined,
+    currentPlayer: undefined,
   },
   setGameState: (game, auth) => {
     set(produce(state => {
@@ -50,7 +50,7 @@ export const useGameStore = create((set, get) => ({
         state.white = game.white
       }
       state.gameState.board = game.board
-      state.gameState.currentUser = game.currentUser
+      state.gameState.currentPlayer = game.currentPlayer
       let symbol = game.black.name === auth.name? BLACK : WHITE 
       if (oldState.symbol !== symbol) {
         state.symbol = symbol
diff --git a/src/main/java/com/bernd/LobbyController.java b/src/main/java/com/bernd/LobbyController.java
@@ -49,7 +49,7 @@ public void matchAction(MatchRequest message, Principal principal) {
     operations.convertAndSend("/topic/lobby/users",
         new UserList(lobbyUsers.users()));
     String gameId = RandomString.get();
-    Game game = games.put(new Game(gameId, user, lookingForMatch, user.name(), new int[][]{
+    Game game = games.put(new Game(gameId, user, lookingForMatch, false, user.name(), false, new int[][]{
         new int[9],
         new int[9],
         new int[9],
diff --git a/src/main/java/com/bernd/game/Board.java b/src/main/java/com/bernd/game/Board.java
@@ -19,19 +19,20 @@ private static StoneGroup getStoneGroup(
     BoardUpdate update = BoardUpdate.builder(dim);
     int liberties = 0;
     PointSet pointsChecked = PointSet.create(dim);
+    pointsChecked.add(xx, yy);
     PointQueue pointsToCheck = PointQueue.create(dim);
     pointsToCheck.offer(xx, yy);
     while (!pointsToCheck.isEmpty()) {
       int ptId = pointsToCheck.poll();
       int y = ptId / dim;
       int x = ptId % dim;
-      pointsChecked.add(x, y);
       update.add(x, y, 0);
       if (y > 0) {
         int bpt = board[y - 1][x];
         if (bpt == 0) {
           liberties++;
         } else if (bpt == color && !pointsChecked.has(x, y - 1)) {
+          pointsChecked.add(x, y - 1);
           pointsToCheck.offer(x, y - 1);
         }
       }
@@ -40,6 +41,7 @@ private static StoneGroup getStoneGroup(
         if (bpt == 0) {
           liberties++;
         } else if (bpt == color && !pointsChecked.has(x, y + 1)) {
+          pointsChecked.add(x, y + 1);
           pointsToCheck.offer(x, y + 1);
         }
       }
@@ -48,6 +50,7 @@ private static StoneGroup getStoneGroup(
         if (bpt == 0) {
           liberties++;
         } else if (bpt == color && !pointsChecked.has(x - 1, y)) {
+          pointsChecked.add(x - 1, y);
           pointsToCheck.offer(x - 1, y);
         }
       }
@@ -56,6 +59,7 @@ private static StoneGroup getStoneGroup(
         if (bpt == 0) {
           liberties++;
         } else if (bpt == color && !pointsChecked.has(x + 1, y)) {
+          pointsChecked.add(x + 1, y);
           pointsToCheck.offer(x + 1, y);
         }
       }
diff --git a/src/main/java/com/bernd/game/Count.java b/src/main/java/com/bernd/game/Count.java
@@ -18,33 +18,37 @@ private static int getImpliedColor(
     }
     int dim = board.length;
     PointSet pointsChecked = PointSet.create(dim);
+    pointsChecked.add(xx, yy);
     PointQueue pointsToCheck = PointQueue.create(dim);
     pointsToCheck.offer(xx, yy);
     while (!pointsToCheck.isEmpty()) {
       int ptId = pointsToCheck.poll();
       int y = ptId / dim;
       int x = ptId % dim;
-      pointsChecked.add(x, y);
       if (board[y][x] != 0) {
         return board[y][x] + TERRITORY;
       }
       if (y > 0 && !pointsChecked.has(x, y - 1)) {
+        pointsChecked.add(x, y - 1);
         pointsToCheck.offer(x, y - 1);
       }
       if (y < dim - 1 && !pointsChecked.has(x, y + 1)) {
+        pointsChecked.add(x, y + 1);
         pointsToCheck.offer(x, y + 1);
       }
       if (x > 0 && !pointsChecked.has(x - 1, y)) {
+        pointsChecked.add(x - 1, y);
         pointsToCheck.offer(x - 1, y);
       }
       if (x < dim - 1 && !pointsChecked.has(x + 1, y)) {
+        pointsChecked.add(x + 1, y);
         pointsToCheck.offer(x + 1, y);
       }
     }
     throw new RuntimeException("empty board");
   }
 
-  private static void markStonesAround(
+  static void markStonesAround(
       int[][] acc,
       int[][] board,
       int xx,
@@ -58,21 +62,23 @@ private static void markStonesAround(
     int baseColor = color - TERRITORY;
     int oppositeColor = baseColor == W ? B : W;
     int dim = board.length;
-    BoardUpdate updater = BoardUpdate.builder(dim, 64);
+    BoardUpdate tracker = BoardUpdate.builder(dim, 64);
     PointQueue pointsToCheck = PointQueue.create(dim);
+    acc[yy][xx] = color;
+    tracker.add(xx, yy);
     pointsToCheck.offer(xx, yy);
     while (!pointsToCheck.isEmpty()) {
       int ptId = pointsToCheck.poll();
       int y = ptId / dim;
       int x = ptId % dim;
-      acc[y][x] = color;
-      updater.add(x, y);
+      tracker.add(x, y);
       if (y > 0) {
         int c = board[y - 1][x];
         if (c == oppositeColor) {
           oppositeStonesFound = true;
         }
-        if (c == 0 && acc[y - 1][x] != color) {
+        if (c == 0 && acc[y - 1][x] == -1) {
+          acc[y - 1][x] = color;
           pointsToCheck.offer(x, y - 1);
         }
       }
@@ -81,7 +87,8 @@ private static void markStonesAround(
         if (c == oppositeColor) {
           oppositeStonesFound = true;
         }
-        if (c == 0 && acc[y + 1][x] != color) {
+        if (c == 0 && acc[y + 1][x] == -1) {
+          acc[y + 1][x] = color;
           pointsToCheck.offer(x, y + 1);
         }
       }
@@ -90,7 +97,8 @@ private static void markStonesAround(
         if (c == oppositeColor) {
           oppositeStonesFound = true;
         }
-        if (c == 0 && acc[y][x - 1] != color) {
+        if (c == 0 && acc[y][x - 1] == -1) {
+          acc[y][x - 1] = color;
           pointsToCheck.offer(x - 1, y);
         }
       }
@@ -99,14 +107,15 @@ private static void markStonesAround(
         if (c == oppositeColor) {
           oppositeStonesFound = true;
         }
-        if (c == 0 && acc[y][x + 1] != color) {
+        if (c == 0 && acc[y][x + 1] == -1) {
+          acc[y][x + 1] = color;
           pointsToCheck.offer(x + 1, y);
         }
       }
     }
     if (oppositeStonesFound) {
-      for (int i = 0; i < updater.size(); i++) {
-        acc[updater.y(i)][updater.x(i)] = 0;
+      for (int i = 0; i < tracker.size(); i++) {
+        acc[tracker.y(i)][tracker.x(i)] = 0;
       }
     }
   }
@@ -125,7 +134,7 @@ public static int[][] count(
     return acc;
   }
 
-  private static int[][] createAcc(int[][] board) {
+  static int[][] createAcc(int[][] board) {
     int[][] result = new int[board.length][];
     for (int i = 0; i < board.length; i++) {
       result[i] = new int[result.length];
diff --git a/src/main/java/com/bernd/game/Remove.java b/src/main/java/com/bernd/game/Remove.java
@@ -17,35 +17,39 @@ private static List<Point> findGroup(
     int dim = board.length;
     PointQueue pointsToCheck = PointQueue.create(dim);
     PointSet pointsChecked = PointSet.create(dim);
+    pointsChecked.add(xx, yy);
     pointsToCheck.offer(xx, yy);
     List<Point> result = new ArrayList<>();
     while (!pointsToCheck.isEmpty()) {
       int ptId = pointsToCheck.poll();
       int y = ptId / dim;
       int x = ptId % dim;
-      pointsChecked.add(x, y);
       result.add(new Point(x, y));
       if (y > 0) {
         int c = board[y - 1][x];
         if (c == color && !pointsChecked.has(x, y - 1)) {
+          pointsChecked.add(x, y - 1);
           pointsToCheck.offer(x, y - 1);
         }
       }
       if (y < dim - 1) {
         int c = board[y + 1][x];
         if (c == color && !pointsChecked.has(x, y + 1)) {
+          pointsChecked.add(x, y + 1);
           pointsToCheck.offer(x, y + 1);
         }
       }
       if (x > 0) {
         int c = board[y][x - 1];
         if (c == color && !pointsChecked.has(x - 1, y)) {
+          pointsChecked.add(x - 1, y);
           pointsToCheck.offer(x - 1, y);
         }
       }
       if (x < dim - 1) {
         int c = board[y][x + 1];
         if (c == color && !pointsChecked.has(x + 1, y)) {
+          pointsChecked.add(x + 1, y);
           pointsToCheck.offer(x + 1, y);
         }
       }
diff --git a/src/main/java/com/bernd/model/Game.java b/src/main/java/com/bernd/model/Game.java
@@ -1,29 +1,84 @@
 package com.bernd.model;
 
 import com.bernd.game.Board;
+import com.bernd.game.Count;
 import com.bernd.util.BoardUpdate;
-import java.util.function.Function;
+import java.util.Arrays;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 public record Game(
     String id,
     User black,
     User white,
-    String currentUser,
+    boolean counting,
+    String currentPlayer,
+    boolean opponentPassed,
     int[][] board
 ) {
 
+  private static final Logger logger = LogManager.getLogger(Game.class);
+
   public Game update(Move move) {
+    try {
+      return updateInternal(move);
+    } catch (RuntimeException e) {
+      StringBuilder sb = new StringBuilder("int[][] position = new int[][]{\n");
+      for (int[] row : board) {
+        String string = Arrays.toString(row).replace('[', '{').replace(']', '}');
+        sb.append("  new int[]" + string + ",\n");
+      }
+      sb.append("};\n");
+      logger.error(sb.toString(), e);
+      return this;
+    }
+  }
+
+  private Game updateInternal(Move move) {
+    if (move.pass()) {
+      if (!opponentPassed) {
+        return game(board, counting, true);
+      }
+      int[][] counted = Count.count(board);
+      return game(counted, true);
+    }
     int x = move.x();
     int y = move.y();
-    int color = currentUser.equals(black().name()) ? Board.B : Board.W;
-    Function<int[][], int[][]> update = BoardUpdate.create(board.length, x, y, color);
-    int[][] rows = update.apply(board);
-    int[][] newRows = Board.removeDeadStonesAround(rows, x, y);
+    int color = currentColor();
+    int[][] updated = BoardUpdate.create(board.length, x, y, color).apply(board);
+    return game(Board.removeDeadStonesAround(updated, x, y));
+  }
+
+  private Game game(
+      int[][] board,
+      boolean counting,
+      boolean opponentPassed) {
     return new Game(
-        this.id,
-        this.black,
-        this.white,
-        currentUser.equals(black.name()) ? white().name() : black().name(),
-        newRows);
+        id,
+        black,
+        white,
+        counting,
+        nextPlayer(),
+        opponentPassed,
+        board);
+  }
+
+  private Game game(
+      int[][] board) {
+    return game(board, counting, opponentPassed);
+  }
+
+  private Game game(
+      int[][] board,
+      boolean counting) {
+    return game(board, counting, opponentPassed);
+  }
+
+  private String nextPlayer() {
+    return currentPlayer.equals(black.name()) ? white().name() : black().name();
+  }
+
+  private int currentColor() {
+    return currentPlayer.equals(black().name()) ? Board.B : Board.W;
   }
 }
diff --git a/src/main/java/com/bernd/model/Move.java b/src/main/java/com/bernd/model/Move.java
diff --git a/src/main/java/com/bernd/util/BoardUpdate.java b/src/main/java/com/bernd/util/BoardUpdate.java
diff --git a/src/test/java/com/bernd/game/CountTest.java b/src/test/java/com/bernd/game/CountTest.java

Original file line number	Diff line number	Diff line change
`@@ -19,19 +19,20 @@ private static StoneGroup getStoneGroup(`
`19`	`19`	`BoardUpdate update = BoardUpdate.builder(dim);`
`20`	`20`	`int liberties = 0;`
`21`	`21`	`PointSet pointsChecked = PointSet.create(dim);`
	`22`	`+ pointsChecked.add(xx, yy);`
`22`	`23`	`PointQueue pointsToCheck = PointQueue.create(dim);`
`23`	`24`	`pointsToCheck.offer(xx, yy);`
`24`	`25`	`while (!pointsToCheck.isEmpty()) {`
`25`	`26`	`int ptId = pointsToCheck.poll();`
`26`	`27`	`int y = ptId / dim;`
`27`	`28`	`int x = ptId % dim;`
`28`		`- pointsChecked.add(x, y);`
`29`	`29`	`update.add(x, y, 0);`
`30`	`30`	`if (y > 0) {`
`31`	`31`	`int bpt = board[y - 1][x];`
`32`	`32`	`if (bpt == 0) {`
`33`	`33`	`liberties++;`
`34`	`34`	`} else if (bpt == color && !pointsChecked.has(x, y - 1)) {`
	`35`	`+ pointsChecked.add(x, y - 1);`
`35`	`36`	`pointsToCheck.offer(x, y - 1);`
`36`	`37`	`}`
`37`	`38`	`}`
`@@ -40,6 +41,7 @@ private static StoneGroup getStoneGroup(`
`40`	`41`	`if (bpt == 0) {`
`41`	`42`	`liberties++;`
`42`	`43`	`} else if (bpt == color && !pointsChecked.has(x, y + 1)) {`
	`44`	`+ pointsChecked.add(x, y + 1);`
`43`	`45`	`pointsToCheck.offer(x, y + 1);`
`44`	`46`	`}`
`45`	`47`	`}`
`@@ -48,6 +50,7 @@ private static StoneGroup getStoneGroup(`
`48`	`50`	`if (bpt == 0) {`
`49`	`51`	`liberties++;`
`50`	`52`	`} else if (bpt == color && !pointsChecked.has(x - 1, y)) {`
	`53`	`+ pointsChecked.add(x - 1, y);`
`51`	`54`	`pointsToCheck.offer(x - 1, y);`
`52`	`55`	`}`
`53`	`56`	`}`
`@@ -56,6 +59,7 @@ private static StoneGroup getStoneGroup(`
`56`	`59`	`if (bpt == 0) {`
`57`	`60`	`liberties++;`
`58`	`61`	`} else if (bpt == color && !pointsChecked.has(x + 1, y)) {`
	`62`	`+ pointsChecked.add(x + 1, y);`
`59`	`63`	`pointsToCheck.offer(x + 1, y);`
`60`	`64`	`}`
`61`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,33 +18,37 @@ private static int getImpliedColor(`
`18`	`18`	`}`
`19`	`19`	`int dim = board.length;`
`20`	`20`	`PointSet pointsChecked = PointSet.create(dim);`
	`21`	`+ pointsChecked.add(xx, yy);`
`21`	`22`	`PointQueue pointsToCheck = PointQueue.create(dim);`
`22`	`23`	`pointsToCheck.offer(xx, yy);`
`23`	`24`	`while (!pointsToCheck.isEmpty()) {`
`24`	`25`	`int ptId = pointsToCheck.poll();`
`25`	`26`	`int y = ptId / dim;`
`26`	`27`	`int x = ptId % dim;`
`27`		`- pointsChecked.add(x, y);`
`28`	`28`	`if (board[y][x] != 0) {`
`29`	`29`	`return board[y][x] + TERRITORY;`
`30`	`30`	`}`
`31`	`31`	`if (y > 0 && !pointsChecked.has(x, y - 1)) {`
	`32`	`+ pointsChecked.add(x, y - 1);`
`32`	`33`	`pointsToCheck.offer(x, y - 1);`
`33`	`34`	`}`
`34`	`35`	`if (y < dim - 1 && !pointsChecked.has(x, y + 1)) {`
	`36`	`+ pointsChecked.add(x, y + 1);`
`35`	`37`	`pointsToCheck.offer(x, y + 1);`
`36`	`38`	`}`
`37`	`39`	`if (x > 0 && !pointsChecked.has(x - 1, y)) {`
	`40`	`+ pointsChecked.add(x - 1, y);`
`38`	`41`	`pointsToCheck.offer(x - 1, y);`
`39`	`42`	`}`
`40`	`43`	`if (x < dim - 1 && !pointsChecked.has(x + 1, y)) {`
	`44`	`+ pointsChecked.add(x + 1, y);`
`41`	`45`	`pointsToCheck.offer(x + 1, y);`
`42`	`46`	`}`
`43`	`47`	`}`
`44`	`48`	`throw new RuntimeException("empty board");`
`45`	`49`	`}`
`46`	`50`
`47`		`- private static void markStonesAround(`
	`51`	`+ static void markStonesAround(`
`48`	`52`	`int[][] acc,`
`49`	`53`	`int[][] board,`
`50`	`54`	`int xx,`
`@@ -58,21 +62,23 @@ private static void markStonesAround(`
`58`	`62`	`int baseColor = color - TERRITORY;`
`59`	`63`	`int oppositeColor = baseColor == W ? B : W;`
`60`	`64`	`int dim = board.length;`
`61`		`- BoardUpdate updater = BoardUpdate.builder(dim, 64);`
	`65`	`+ BoardUpdate tracker = BoardUpdate.builder(dim, 64);`
`62`	`66`	`PointQueue pointsToCheck = PointQueue.create(dim);`
	`67`	`+ acc[yy][xx] = color;`
	`68`	`+ tracker.add(xx, yy);`
`63`	`69`	`pointsToCheck.offer(xx, yy);`
`64`	`70`	`while (!pointsToCheck.isEmpty()) {`
`65`	`71`	`int ptId = pointsToCheck.poll();`
`66`	`72`	`int y = ptId / dim;`
`67`	`73`	`int x = ptId % dim;`
`68`		`- acc[y][x] = color;`
`69`		`- updater.add(x, y);`
	`74`	`+ tracker.add(x, y);`
`70`	`75`	`if (y > 0) {`
`71`	`76`	`int c = board[y - 1][x];`
`72`	`77`	`if (c == oppositeColor) {`
`73`	`78`	`oppositeStonesFound = true;`
`74`	`79`	`}`
`75`		`- if (c == 0 && acc[y - 1][x] != color) {`
	`80`	`+ if (c == 0 && acc[y - 1][x] == -1) {`
	`81`	`+ acc[y - 1][x] = color;`
`76`	`82`	`pointsToCheck.offer(x, y - 1);`
`77`	`83`	`}`
`78`	`84`	`}`
`@@ -81,7 +87,8 @@ private static void markStonesAround(`
`81`	`87`	`if (c == oppositeColor) {`
`82`	`88`	`oppositeStonesFound = true;`
`83`	`89`	`}`
`84`		`- if (c == 0 && acc[y + 1][x] != color) {`
	`90`	`+ if (c == 0 && acc[y + 1][x] == -1) {`
	`91`	`+ acc[y + 1][x] = color;`
`85`	`92`	`pointsToCheck.offer(x, y + 1);`
`86`	`93`	`}`
`87`	`94`	`}`
`@@ -90,7 +97,8 @@ private static void markStonesAround(`
`90`	`97`	`if (c == oppositeColor) {`
`91`	`98`	`oppositeStonesFound = true;`
`92`	`99`	`}`
`93`		`- if (c == 0 && acc[y][x - 1] != color) {`
	`100`	`+ if (c == 0 && acc[y][x - 1] == -1) {`
	`101`	`+ acc[y][x - 1] = color;`
`94`	`102`	`pointsToCheck.offer(x - 1, y);`
`95`	`103`	`}`
`96`	`104`	`}`
`@@ -99,14 +107,15 @@ private static void markStonesAround(`
`99`	`107`	`if (c == oppositeColor) {`
`100`	`108`	`oppositeStonesFound = true;`
`101`	`109`	`}`
`102`		`- if (c == 0 && acc[y][x + 1] != color) {`
	`110`	`+ if (c == 0 && acc[y][x + 1] == -1) {`
	`111`	`+ acc[y][x + 1] = color;`
`103`	`112`	`pointsToCheck.offer(x + 1, y);`
`104`	`113`	`}`
`105`	`114`	`}`
`106`	`115`	`}`
`107`	`116`	`if (oppositeStonesFound) {`
`108`		`- for (int i = 0; i < updater.size(); i++) {`
`109`		`- acc[updater.y(i)][updater.x(i)] = 0;`
	`117`	`+ for (int i = 0; i < tracker.size(); i++) {`
	`118`	`+ acc[tracker.y(i)][tracker.x(i)] = 0;`
`110`	`119`	`}`
`111`	`120`	`}`
`112`	`121`	`}`
`@@ -125,7 +134,7 @@ public static int[][] count(`
`125`	`134`	`return acc;`
`126`	`135`	`}`
`127`	`136`
`128`		`- private static int[][] createAcc(int[][] board) {`
	`137`	`+ static int[][] createAcc(int[][] board) {`
`129`	`138`	`int[][] result = new int[board.length][];`
`130`	`139`	`for (int i = 0; i < board.length; i++) {`
`131`	`140`	`result[i] = new int[result.length];`
Original file line number	Diff line number	Diff line change
`@@ -17,35 +17,39 @@ private static List<Point> findGroup(`
`17`	`17`	`int dim = board.length;`
`18`	`18`	`PointQueue pointsToCheck = PointQueue.create(dim);`
`19`	`19`	`PointSet pointsChecked = PointSet.create(dim);`
	`20`	`+ pointsChecked.add(xx, yy);`
`20`	`21`	`pointsToCheck.offer(xx, yy);`
`21`	`22`	`List<Point> result = new ArrayList<>();`
`22`	`23`	`while (!pointsToCheck.isEmpty()) {`
`23`	`24`	`int ptId = pointsToCheck.poll();`
`24`	`25`	`int y = ptId / dim;`
`25`	`26`	`int x = ptId % dim;`
`26`		`- pointsChecked.add(x, y);`
`27`	`27`	`result.add(new Point(x, y));`
`28`	`28`	`if (y > 0) {`
`29`	`29`	`int c = board[y - 1][x];`
`30`	`30`	`if (c == color && !pointsChecked.has(x, y - 1)) {`
	`31`	`+ pointsChecked.add(x, y - 1);`
`31`	`32`	`pointsToCheck.offer(x, y - 1);`
`32`	`33`	`}`
`33`	`34`	`}`
`34`	`35`	`if (y < dim - 1) {`
`35`	`36`	`int c = board[y + 1][x];`
`36`	`37`	`if (c == color && !pointsChecked.has(x, y + 1)) {`
	`38`	`+ pointsChecked.add(x, y + 1);`
`37`	`39`	`pointsToCheck.offer(x, y + 1);`
`38`	`40`	`}`
`39`	`41`	`}`
`40`	`42`	`if (x > 0) {`
`41`	`43`	`int c = board[y][x - 1];`
`42`	`44`	`if (c == color && !pointsChecked.has(x - 1, y)) {`
	`45`	`+ pointsChecked.add(x - 1, y);`
`43`	`46`	`pointsToCheck.offer(x - 1, y);`
`44`	`47`	`}`
`45`	`48`	`}`
`46`	`49`	`if (x < dim - 1) {`
`47`	`50`	`int c = board[y][x + 1];`
`48`	`51`	`if (c == color && !pointsChecked.has(x + 1, y)) {`
	`52`	`+ pointsChecked.add(x + 1, y);`
`49`	`53`	`pointsToCheck.offer(x + 1, y);`
`50`	`54`	`}`
`51`	`55`	`}`