add button to reset the counting

Author: h908714124

src/main/client/src/Play.jsx

@@ -16,6 +16,7 @@ import {
 import {
   StompContext,
   BLACK,
+  WHITE,
   TERRITORY,
   getColorClassName,
 } from "./util.js"
@@ -41,11 +42,8 @@ export const Play = () => {
   let stompClient = useContext(StompContext)
   let auth = useAuthStore(state => state.auth)
   let setGameState = useGameStore(state => state.setGameState)
-  let black = useGameStore(state => state.black)
-  let white = useGameStore(state => state.white)
   let { board, currentPlayer, counting } = useGameStore(state => state.gameState)
   let initialized = useRef()
-  let opponent = auth.name === black.name ? white : black
   useEffect(() => {
     if (initialized.current) {
       return
@@ -74,6 +72,15 @@ export const Play = () => {
       }),
     })
   }, [stompClient, gameId])
+  let onResetCounting = useCallback(() => {
+    stompClient.publish({
+      destination: "/app/game/move",
+      body: JSON.stringify({
+        id: gameId,
+        resetCounting: true,
+      }),
+    })
+  }, [stompClient, gameId])
   let onClick = useCallback(({ x, y }) => {
     stompClient.publish({
       destination: "/app/game/move",
@@ -87,6 +94,7 @@ export const Play = () => {
   if (!board) {
     return <div>Spieldaten werden geladen...</div>
   }
+  let result = counting ? getResult(board) : undefined
   return (
     <div className="mt-2 ml-4">
       <div className="relative w-full h-1">
@@ -120,15 +128,24 @@ export const Play = () => {
           Pass
         </Button>
       </div>
-      <div className="mt-2">
-      {
-        counting ? "" : (
-        currentPlayer === auth.name ?
-          "Jetzt bin ich dran" : 
-          (opponent.name + " ist dran...")
-        )
-      }
-      </div>
+      {counting && (
+         <div className="mt-2">
+           <Button
+             onClick={onResetCounting}>
+             Reset Counting
+           </Button>
+         </div>
+      )}
+      {result && (
+         <div className="mt-2">
+           {"w: " + result.w + ", b: " + result.b}
+         </div>
+      )}
+      {!counting && (
+         <div className="mt-2">
+           {currentPlayer + " ist dran..."}
+         </div>
+      )}
       </div>
     </div>
   )
@@ -215,3 +232,19 @@ function CountingTile({ groupInfo, onClick }) {
     </div>
   )
 }
+
+function getResult(board) {
+  let w = 0, b = 0
+  for (let y = 0; y < board.length; y++) {
+    for (let x = 0; x < board[y].length; x++) {
+      let { color } = board[y][x]
+      if ((color & WHITE) !== 0) {
+        w++
+      }
+      if ((color & BLACK) !== 0) {
+        b++
+      }
+    }
+  }
+  return { w, b }
+}

src/main/java/com/bernd/game/Count.java

@@ -3,9 +3,9 @@
 import com.bernd.util.Util;
 import java.util.Arrays;
 
-import static com.bernd.game.Board.B;
 import static com.bernd.game.Board.TERRITORY;
-import static com.bernd.game.Board.W;
+import static com.bernd.util.Util.COLORS;
+import static com.bernd.util.Util.MARKERS;
 import static com.bernd.util.Util.isStone;
 import static com.bernd.util.Util.keepMarkers;
 
@@ -67,12 +67,11 @@ static void colorEmptyTerritory(
       return;
     }
     boolean oppositeStonesFound = false;
-    int oppositeColor = (color & W) != 0 ? B : W;
+    int oppositeColor = (color & COLORS) ^ COLORS;
     int dim = board.length;
     PointList tracker = PointList.create(dim);
     PointQueue pointsToCheck = PointQueue.create(dim);
-    acc[yy][xx] = color;
-    tracker.add(xx, yy);
+    acc[yy][xx] = keepMarkers(color, board[yy][xx]);
     pointsToCheck.offer(xx, yy);
     while (!pointsToCheck.isEmpty()) {
       int ptId = pointsToCheck.poll();
@@ -81,47 +80,39 @@ static void colorEmptyTerritory(
       tracker.add(x, y);
       if (y > 0) {
         int c = board[y - 1][x];
-        if (c == oppositeColor) {
-          oppositeStonesFound = true;
-        }
+        oppositeStonesFound |= c == oppositeColor;
         if (Util.isEmpty(c) && acc[y - 1][x] == -1) {
-          acc[y - 1][x] = keepMarkers(color, c);
+          acc[y - 1][x] = color | c & MARKERS;
           pointsToCheck.offer(x, y - 1);
         }
       }
       if (y < dim - 1) {
         int c = board[y + 1][x];
-        if (c == oppositeColor) {
-          oppositeStonesFound = true;
-        }
+        oppositeStonesFound |= c == oppositeColor;
         if (Util.isEmpty(c) && acc[y + 1][x] == -1) {
-          acc[y + 1][x] = keepMarkers(color, c);
+          acc[y + 1][x] = color | c & MARKERS;
           pointsToCheck.offer(x, y + 1);
         }
       }
       if (x > 0) {
         int c = board[y][x - 1];
-        if (c == oppositeColor) {
-          oppositeStonesFound = true;
-        }
+        oppositeStonesFound |= c == oppositeColor;
         if (Util.isEmpty(c) && acc[y][x - 1] == -1) {
-          acc[y][x - 1] = keepMarkers(color, c);
+          acc[y][x - 1] = color | c & MARKERS;
           pointsToCheck.offer(x - 1, y);
         }
       }
       if (x < dim - 1) {
         int c = board[y][x + 1];
-        if (c == oppositeColor) {
-          oppositeStonesFound = true;
-        }
+        oppositeStonesFound |= c == oppositeColor;
         if (Util.isEmpty(c) && acc[y][x + 1] == -1) {
-          acc[y][x + 1] = keepMarkers(color, c);
+          acc[y][x + 1] = color | c & MARKERS;
           pointsToCheck.offer(x + 1, y);
         }
       }
     }
     if (oppositeStonesFound) {
-      tracker.forEach((x, y) -> acc[y][x] = 0);
+      tracker.forEach((x, y) -> acc[y][x] = board[y][x] & ~TERRITORY);
     }
   }
 

src/main/java/com/bernd/game/Toggle.java

@@ -3,6 +3,8 @@
 import com.bernd.util.BoardUpdate;
 import java.util.function.Function;
 
+import static com.bernd.game.Board.B;
+import static com.bernd.game.Board.W;
 import static com.bernd.game.Board.REMOVED;
 import static com.bernd.game.Board.TERRITORY;
 
@@ -68,4 +70,25 @@ public static int[][] toggleStonesAt(
     Function<int[][], int[][]> update = toggleRemoved(board, x, y);
     return update.apply(board);
   }
+
+  public static int[][] resetCounting(
+      int[][] board) {
+    int dim = board.length;
+    BoardUpdate update = BoardUpdate.builder(dim);
+    for (int y = 0; y < dim; y++) {
+      for (int x = 0; x < board[y].length; x++) {
+        int color = board[y][x];
+        if ((color & REMOVED) != 0) {
+          color = color ^ (B | W);
+          color &= ~REMOVED;
+          color &= ~TERRITORY;
+        }
+        if ((color & TERRITORY) != 0) {
+          color = 0;
+        }
+        update.add(x, y, color);
+      }
+    }
+    return update.apply(board);
+  }
 }

src/main/java/com/bernd/model/Game.java

@@ -36,9 +36,12 @@ public Game update(Move move) {
 
   private Game updateInternal(Move move) {
     if (counting) {
+      if (move.resetCounting()) {
+        int[][] resetted = Toggle.resetCounting(board);
+        return game(Count.count(resetted));
+      }
       int[][] toggled = Toggle.toggleStonesAt(board, move.x(), move.y());
-      int[][] counted = Count.count(toggled);
-      return game(counted);
+      return game(Count.count(toggled));
     }
     if (move.pass()) {
       if (opponentPassed) {

src/main/java/com/bernd/model/Move.java

@@ -1,4 +1,9 @@
 package com.bernd.model;
 
-public record Move(String id, boolean pass, int x, int y) {
+public record Move(
+  String id,
+  boolean pass,
+  boolean resetCounting,
+  int x,
+  int y) {
 }

src/main/java/com/bernd/util/Util.java

@@ -1,14 +1,12 @@
 package com.bernd.util;
 
-import java.util.Arrays;
-
 import static com.bernd.game.Board.B;
 import static com.bernd.game.Board.REMOVED;
 import static com.bernd.game.Board.W;
 
 public final class Util {
-  private static final int MARKERS = ~B & ~W;
-  private static final int COLORS = B | W;
+  public static final int MARKERS = ~B & ~W;
+  public static final int COLORS = B | W;
 
   private Util() {
   }
@@ -41,12 +39,4 @@ public static int divUp(int i, int div) {
   public static boolean isStone(int color) {
     return (color & COLORS) != 0 && (color & MARKERS) == 0;
   }
-
-  public static int[][] copyBoard(int[][] board) {
-    int[][] result = new int[board.length][];
-    for (int y = 0; y < board.length; y++) {
-      result[y] = Arrays.copyOf(board[y], board[y].length);
-    }
-    return result;
-  }
 }

src/test/java/com/bernd/game/CountTest.java

@@ -223,6 +223,27 @@ void testCornerEyeCountImpliedColor() {
     assertEquals(W | TERRITORY, getImpliedColor(board, 1, 1));
   }
 
+  @Test
+  void testCountWhiteL() {
+    int r = W | REMOVED;
+    int f = B | REMOVED | TERRITORY;
+    int t = B | TERRITORY;
+    int[][] result = Count.count(new int[][]{
+        new int[]{t, B, r, 0, 0},
+        new int[]{B, B, r, 0, 0},
+        new int[]{r, r, r, 0, 0},
+        new int[]{0, 0, 0, 0, 0},
+        new int[]{0, 0, 0, 0, 0},
+    });
+    assertArrayEquals(new int[][]{
+        new int[]{t, B, f, t, t},
+        new int[]{B, B, f, t, t},
+        new int[]{f, f, f, t, t},
+        new int[]{t, t, t, t, t},
+        new int[]{t, t, t, t, t},
+    }, result);
+  }
+
   static int[][] createEmptyBoard(int dim) {
     int[][] board = new int[dim][];
     for (int y = 0; y < dim; y++) {

src/test/java/com/bernd/game/ToggleTest.java

@@ -67,4 +67,46 @@ void testCornerEyeToggle() {
         new int[]{0, 0, 0, 0, 0},
     }, result);
   }
+
+  @Test
+  void testToggleWhiteL() {
+    int r = W | REMOVED;
+    int t = B | TERRITORY;
+    int[][] position = new int[][]{
+        new int[]{t, B, W, 0, 0},
+        new int[]{B, B, W, 0, 0},
+        new int[]{W, W, W, 0, 0},
+        new int[]{0, 0, 0, 0, 0},
+        new int[]{0, 0, 0, 0, 0},
+    };
+    int[][] result = Toggle.toggleStonesAt(position, 0, 2);
+    assertArrayEquals(new int[][]{
+        new int[]{t, B, r, 0, 0},
+        new int[]{B, B, r, 0, 0},
+        new int[]{r, r, r, 0, 0},
+        new int[]{0, 0, 0, 0, 0},
+        new int[]{0, 0, 0, 0, 0},
+    }, result);
+  }
+
+  @Test
+  void testResetCounting() {
+    int f = B | REMOVED | TERRITORY;
+    int t = B | TERRITORY;
+    int[][] position = new int[][]{
+        new int[]{t, B, f, t, t},
+        new int[]{B, B, f, t, t},
+        new int[]{f, f, f, t, t},
+        new int[]{t, t, t, t, t},
+        new int[]{t, t, t, t, t},
+    };
+    int[][] result = Toggle.resetCounting(position);
+    assertArrayEquals(new int[][]{
+        new int[]{0, B, W, 0, 0},
+        new int[]{B, B, W, 0, 0},
+        new int[]{W, W, W, 0, 0},
+        new int[]{0, 0, 0, 0, 0},
+        new int[]{0, 0, 0, 0, 0},
+    }, result);
+  }
 }