Mon Jul 3 04:05:00 UTC 2023 inscode

src/App.vue

@@ -22,14 +22,14 @@ async function playChess(item, row, col) {
   if (isWin.length || item !== is_empty) return
   lattices.value[row][col] = is_black
   const test = checkWin({ row, col, board: lattices.value, player: is_black, win_size: win_size.value })
-  if (test.length >= win_size.value) {
+  if (test) {
     isWin = test
     return
   } else {
     const [x, y] = robotPlay(lattices.value, is_white, win_size.value)
     lattices.value[x][y] = is_white
     const test = checkWin({ row: x, col: y, board: lattices.value, player: is_white, win_size: win_size.value })
-    if (test.length >= win_size.value) {
+    if (test) {
       isWin = test
     }
   }

src/utils/index.js

@@ -11,28 +11,31 @@ export const directions = [
   [1, -1]        // 左下方向
 ]
 
+/**
+ * @typedef Param
+ * @property {object} param 对象a
+ * @property {number} param.row 行
+ * @property {number} param.col 列
+ * @property {(is_empty|is_white|is_black)[]} param.board 棋盘
+ * @property {is_white|is_black|is_empty} [param.player] 当前棋子类型
+ * @property {number} param.win_size 需要几个棋子才赢
+ */
+
 /**
  * 检查四个方向连续的棋子数
- * @param {object} param 
- * @param {number} param.row 行
- * @param {number} param.col 列
- * @param {(is_empty|is_white|is_black)[]} param.board 棋盘
- * @param {is_white|is_black} [param.player] 当前棋子类型
- * @param {number} param.win_size 需要几个棋子才赢
- * @param {[][]} [param.direction] 方向
- * @returns 
+ * @param {Param}
+ * @returns {[number, number][] | false} 赢棋的下标二维数组 或者 不能赢
  */
-export function checkWin({ row, col, board, player, win_size, direction }) {
+export function checkWin({ row, col, board, player, win_size }) {
   const _row = board.length;
   const _col = board[0].length
   const pieceType = player ?? board[row][col]
   let res = []
 
-  const _directions = direction ? [direction] : directions;
 
-  for (let i = 0; i < _directions.length; i++) {
+  for (let i = 0; i < directions.length; i++) {
     res = [[row, col]];
-    const [dx, dy] = _directions[i];
+    const [dx, dy] = directions[i];
     let x = row + dx;
     let y = col + dy;
 
@@ -57,7 +60,7 @@ export function checkWin({ row, col, board, player, win_size, direction }) {
     }
   }
   // 当前空位，可以结成多少颗连珠
-  return res;
+  return false;
 }
 
 /**
@@ -84,16 +87,16 @@ export function robotPlay(board, robot, win_size) {
 
     // 判断下子后是否获胜
     const win = checkWin({ row, col, board, player: robot, win_size });
-    if (win.length >= win_size) {
+    if (win) {
       return [row, col]
     } else {
       // 判断对手是否能在下一步获胜
       const oppWin = checkWin({ row, col, board, player: is_black, win_size });
-      if (oppWin.length >= win_size) {
+      if (oppWin) {
         return [row, col]
       } else {
         // 这里要应该是要返回这个位置的分数
-        score = estimateScore({ row, col, board })
+        score = estimateScore({ row, col, board, win_size })
       }
     }
 
@@ -122,22 +125,6 @@ const direction_4 = [
   [1, 0]]
 ]
 
-// 获取一个一个方向上的棋子数
-function getDirectionScore(board, row, col, [x, y]) {
-  let res = 0
-  let _row = row + x
-  let _col = col + y
-  while (true) {
-    if (_row < 0 || _col < 0 || !board[_row] || board[_row][_col] !== is_black) {
-      break;
-    }
-    res += 1
-    _row += x
-    _col += y
-  }
-  // 判断边距
-  return res
-}
 /**
  * 计分
  * 零颗棋子记 个位数 的积分
@@ -156,6 +143,44 @@ function getDirectionScore(board, row, col, [x, y]) {
  * 如果在棋盘边缘，需要判断连子最多有几颗,小于5颗，可以直接放弃当前位置
  */
 
+/**
+ * 获取获取边界距离
+ * @param {number} size 
+ * @param {number} num 
+ */
+function getBoundary(size, num) {
+  const HALF = size / 2
+
+  return (num > HALF ? size - num : num) + 1 // 当前位置算进去
+}
+
+/**
+ * 获取一个一个方向上的棋子数
+ * @param {*} board 
+ * @param {*} row 
+ * @param {*} col 
+ * @param {*} param3 
+ * @param {*} piece_type 
+ * @returns 
+ */
+function getDirectionScore(board, row, col, [x, y], piece_type) {
+  const ROW = board.length
+  const COL = board[0].length
+  let res = 0
+  let _row = row + x
+  let _col = col + y
+  while (true) {
+    if (_row < 0 || _col < 0 || !board[_row] || board[_row][_col] !== piece_type) {
+      break;
+    }
+    res += 1
+    _row += x
+    _col += y
+  }
+  // 判断边距
+  return res
+}
+
 /**
  * 评估每个空位置的价值，从八个方向去计算,
  * 计分规则 1,10,100,1000,10000,100000 根据棋子数量计分，每多一颗棋子，分数乘以10
@@ -165,9 +190,9 @@ function getDirectionScore(board, row, col, [x, y]) {
  * @param {number} Estimate.col
  * @return {number}
  */
-function estimateScore({ board, row, col }) {
+function estimateScore({ board, row, col, win_size }) {
   return direction_4.reduce((r, [p1, p2]) => {
-    const square = getDirectionScore(board, row, col, p1) + getDirectionScore(board, row, col, p2)
+    const square = getDirectionScore(board, row, col, p1, win_size, is_black) + getDirectionScore(board, row, col, p2, win_size, is_black)
     return r + 10 ** square
   }, 0)
 }