wip client count

Author: h908714124

src/main/client/src/Game.jsx

@@ -45,6 +45,7 @@ export const Game = () => {
   let auth = useAuthStore(state => state.auth)
   let setGameState = useGameStore(state => state.setGameState)
   let queueStatus = useGameStore(state => state.queueStatus)
+  let queueLength = useGameStore(state => state.queueLength)
   let addMove = useGameStore(state => state.addMove)
   let currentPlayer = useGameStore(state => state.currentPlayer)
   let { board, currentColor, counting, forbidden } = useGameStore(state => state.gameState)
@@ -157,11 +158,12 @@ export const Game = () => {
       destination: "/app/game/move",
       body: JSON.stringify({
         id: gameId,
+        n: queueLength(),
         x: cursor_x,
         y: cursor_y,
       }),
     })
-  }, [context, currentPlayer, currentColor, auth, board, gameId, stompClient, counting, forbidden_x, forbidden_y])
+  }, [context, currentPlayer, currentColor, auth, board, gameId, stompClient, counting, forbidden_x, forbidden_y, queueLength])
 
   useEffect(() => {
     if (!board.length) {

src/main/client/src/feature/GamePanel.jsx

@@ -48,6 +48,7 @@ function Panel({zoom, setZoom}) {
   let auth = useAuthStore(state => state.auth)
   let black = useGameStore(state => state.black)
   let white = useGameStore(state => state.white)
+  let queueLength = useGameStore(state => state.queueLength)
   let currentPlayer = useGameStore(state => state.currentPlayer)
   let { board, counting } = useGameStore(state => state.gameState)
   let navigate = useNavigate()
@@ -59,19 +60,21 @@ function Panel({zoom, setZoom}) {
       destination: "/app/game/move",
       body: JSON.stringify({
         id: gameId,
+        n: queueLength(),
         pass: true,
       }),
     })
-  }, [stompClient, gameId])
+  }, [stompClient, gameId, queueLength])
   let onResetCounting = useCallback(() => {
     stompClient.publish({
       destination: "/app/game/move",
       body: JSON.stringify({
         id: gameId,
+        n: queueLength(),
         resetCounting: true,
       }),
     })
-  }, [stompClient, gameId])
+  }, [stompClient, gameId, queueLength])
   if (!board.length) {
     return <span>Loading...</span>
   }

src/main/client/src/model/count.js

@@ -17,8 +17,94 @@ import {
   TERRITORY,
   REMOVED_B,
   REMOVED_W,
+  TOGGLE_B,
+  TOGGLE_W,
+  TOGGLE_STUFF,
 } from "../util.js"
 
+export function count(board) {
+  let acc = createAcc(board.length)
+  for (let y = 0; y < board.length; y++) {
+    let row = board[y]
+    for (let x = 0; x < row.length; x++) {
+      if (acc[y][x] === -1) {
+        colorEmptyTerritory(board, acc, x, y)
+      }
+    }
+  }
+  return acc
+}
+
+function updateToggleStonesAt(board, x, y, color, pointsChecked, pointsToCheck) {
+  let dim = board.length
+  if (Math.min(x, y) < 0 || Math.max(x, y) >= dim) {
+    return
+  }
+  let c = board[y][x]
+  if (c !== color) {
+    return
+  }
+  if (pointsChecked.has(x, y)) {
+    return
+  }
+  pointsChecked.add(x, y)
+  pointsToCheck.offer(x, y)
+}
+
+export function toggleStonesAt(board, xx, yy) {
+  let color = board[yy][xx]
+  if (!(color & TOGGLE_STUFF)) {
+    return board
+  }
+  let dim = board.length
+  let result = new PointList(dim)
+  let pointsToCheck = new PointQueue(dim)
+  let pointsChecked = new PointSet(dim)
+  pointsChecked.add(xx, yy)
+  pointsToCheck.offer(xx, yy)
+  while (!pointsToCheck.isEmpty()) {
+    let ptId = pointsToCheck.poll()
+    let y = Math.trunc(ptId / dim)
+    let x = ptId % dim
+    result.add(x, y)
+    updateToggleStonesAt(board, x, y - 1, color, pointsChecked, pointsToCheck)
+    updateToggleStonesAt(board, x, y + 1, color, pointsChecked, pointsToCheck)
+    updateToggleStonesAt(board, x - 1, y, color, pointsChecked, pointsToCheck)
+    updateToggleStonesAt(board, x + 1, y, color, pointsChecked, pointsToCheck)
+  }
+  let updated = board.slice()
+  result.forEach((x, y) => {
+    if (updated[y] === board[y]) {
+      updated[y] = board[y].slice()
+    }
+    updated[y][x] = toggleRemoved(updated[y][x])
+  })
+  return updated
+}
+
+export function resetCounting(board) {
+  let dim = board.length
+  let updated = board.slice()
+  for (let y = 0; y < dim; y++) {
+    updated[y] = board[y].slice()
+    for (let x = 0; x < dim; x++) {
+      updated[y][x] = resurrect(board[y][x]) & COLORS
+    }
+  }
+  return updated
+}
+
+function updateFindStone(dim, x, y, pointsChecked, pointsToCheck) {
+  if (Math.min(x, y) < 0 || Math.max(x, y) >= dim) {
+    return
+  }
+  if (pointsChecked.has(x, y)) {
+    return
+  }
+  pointsChecked.add(x, y)
+  pointsToCheck.offer(x, y)
+}
+
 function findStone(board, xx, yy) {
   if (hasStone(board[yy][xx])) {
     return board[yy][xx]
@@ -35,22 +121,10 @@ function findStone(board, xx, yy) {
     if (hasStone(board[y][x])) {
       return board[y][x]
     }
-    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)
-    }
+    updateFindStone(dim, x, y - 1, pointsChecked, pointsToCheck)
+    updateFindStone(dim, x, y + 1, pointsChecked, pointsToCheck)
+    updateFindStone(dim, x - 1, y, pointsChecked, pointsToCheck)
+    updateFindStone(dim, x + 1, y, pointsChecked, pointsToCheck)
   }
   return 0
 }
@@ -117,19 +191,6 @@ function colorEmptyTerritory(board, acc, xx, yy) {
   }
 }
 
-export function count(board) {
-  let acc = createAcc(board.length)
-  for (let y = 0; y < board.length; y++) {
-    let row = board[y]
-    for (let x = 0; x < row.length; x++) {
-      if (acc[y][x] === -1) {
-        colorEmptyTerritory(board, acc, x, y)
-      }
-    }
-  }
-  return acc
-}
-
 function getTerritoryMarker(found, empty) {
   if ((empty & asRemoved(found)) !== 0) {
     return found // resurrect
@@ -157,6 +218,26 @@ function asRemoved(color) {
   return color
 }
 
+function toggleRemoved(color) {
+  if (color & TOGGLE_B) {
+    return color ^ TOGGLE_B
+  }
+  if (color & TOGGLE_W) {
+    return color ^ TOGGLE_W
+  }
+  return color
+}
+
+function resurrect(color) {
+  if (color & REMOVED_B) {
+    return color ^ TOGGLE_B
+  }
+  if (color & REMOVED_W) {
+    return color ^ TOGGLE_W
+  }
+  return color
+}
+
 function createAcc(dim) {
   let result = Array(dim)
   for (let y = 0; y < dim; y++) {

src/main/client/src/model/count.test.js

@@ -0,0 +1,94 @@
+import {
+  expect,
+  test,
+} from "vitest"
+import {
+  count,
+  toggleStonesAt,
+  resetCounting,
+} from "./count.js"
+import {
+  BLACK,
+  WHITE,
+  TERRITORY_B,
+  TERRITORY_W,
+  REMOVED_W,
+  REMOVED_B,
+} from "../util.js"
+
+test("territoryChangeOwner", () => {
+  let B = BLACK
+  let t = TERRITORY_W
+  let r = TERRITORY_W | REMOVED_B
+  let v = TERRITORY_B
+  let k = REMOVED_W
+  let s = REMOVED_W | TERRITORY_B
+  let position = [
+      [t, r, k, 0, 0],
+      [r, r, k, 0, 0],
+      [k, k, k, B, 0],
+      [0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0],
+  ]
+  let counted = count(position)
+  expect(counted).toEqual(mapInt([
+      [v, B, s, v, v],
+      [B, B, s, v, v],
+      [s, s, s, B, v],
+      [v, v, v, v, v],
+      [v, v, v, v, v],
+  ]))
+})
+
+test("toggle", () => {
+  let B = BLACK
+  let W = WHITE
+  let t = TERRITORY_W
+  let r = TERRITORY_W | REMOVED_B
+  let k = REMOVED_W
+  let position = [
+      [t, r, W, 0, 0],
+      [r, r, W, 0, 0],
+      [W, W, W, B, 0],
+      [0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0],
+  ]
+  let toggled = toggleStonesAt(position, 0, 2)
+  expect(toggled).toEqual([
+      [t, r, k, 0, 0],
+      [r, r, k, 0, 0],
+      [k, k, k, B, 0],
+      [0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0],
+  ])
+})
+
+test("reset", () => {
+  let B = BLACK
+  let W = WHITE
+  let f = REMOVED_W | TERRITORY_B
+  let t = TERRITORY_B
+  let position = [
+      [t, B, f, t, t],
+      [B, B, f, t, t],
+      [f, f, f, t, t],
+      [t, t, t, t, t],
+      [t, t, t, t, t],
+  ]
+  let result = resetCounting(position)
+  expect(result).toEqual([
+      [0, B, W, 0, 0],
+      [B, B, W, 0, 0],
+      [W, W, W, 0, 0],
+      [0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0],
+  ])
+})
+
+function mapInt(ar) {
+  let result = Array(ar.length)
+  for (let y = 0; y < ar.length; y++) {
+    result[y] = new Int32Array(ar[y])
+  }
+  return result
+}

src/main/client/src/store.js

@@ -20,6 +20,11 @@ import {
 import {
   getForbidden,
 } from "./model/ko.js"
+import {
+  count,
+  toggleStonesAt,
+  resetCounting,
+} from "./model/count.js"
 
 export const useAuthStore = create((set) => ({
   auth: {
@@ -63,6 +68,9 @@ export const useGameStore = create((set, get) => ({
         get().white.name :
         get().black.name
   },
+  queueLength: () => {
+    return get().moves.length
+  },
   gameState: {
     board: [],
     currentColor: BLACK,
@@ -82,8 +90,15 @@ export const useGameStore = create((set, get) => ({
       if (move.counting) {
         state.moves.push({...move, dead: PointList.empty()})
         state.gameState.counting = true
-        state.baseBoard = move.board
-        state.gameState.board = rehydrate(move.board)
+        if (move.resetCounting) {
+          let updated = count(resetCounting(get().baseBoard))
+          state.baseBoard = updated
+          state.gameState.board = rehydrate(updated)
+        } else {
+          let updated = count(toggleStonesAt(get().baseBoard, move.x, move.y))
+          state.baseBoard = updated
+          state.gameState.board = rehydrate(updated)
+        }
         return
       }
       let [dead, updated] = updateBoard(get().baseBoard, move)

src/main/client/src/util.js

@@ -14,6 +14,10 @@ export const TERRITORY_W = 4
 export const REMOVED_B = 8
 export const REMOVED_W = 16
 
+export const TOGGLE_B = REMOVED_B | BLACK
+export const TOGGLE_W = REMOVED_W | WHITE
+export const TOGGLE_STUFF = TOGGLE_B | TOGGLE_W
+
 export const TERRITORY = TERRITORY_W | TERRITORY_B
 export const ANY_REMOVED = REMOVED_W | REMOVED_B
 

src/main/java/com/bernd/GameController.java

@@ -1,5 +1,6 @@
 package com.bernd;
 
+import com.bernd.game.Board;
 import com.bernd.model.AcceptRequest;
 import com.bernd.model.ActiveGame;
 import com.bernd.model.CountingMove;
@@ -58,16 +59,16 @@ public void action(Move move, Principal principal) {
     }
     int moveNumber = game.moves().size();
     int color = game.currentColor();
-    if (!principal.getName().equals(game.currentPlayer())) {
+    String currentPlayer = game.currentColor() == Board.B ? game.black().name() : game.white().name();
+    if (!principal.getName().equals(currentPlayer)) {
       return; // discard
     }
+    if (move.n() != moveNumber) {
+      return;
+    }
     Game updated = game.update(move);
     games.put(updated);
-    if (updated.counting()) {
-      operations.convertAndSend("/topic/move/" + game.id(), CountingMove.create(color, moveNumber, updated.board()));
-    } else {
-      operations.convertAndSend("/topic/move/" + game.id(), move.toView(color, moveNumber));
-    }
+    operations.convertAndSend("/topic/move/" + game.id(), move.toView(color, updated.counting()));
   }
 
   @ResponseBody