国际象棋，防止棋子在斜向移动时跳过其他棋子。

huangapple
go评论116阅读模式
英文:

Chess, preventing a piece from jumping over pieces when going diagonally

问题

希望你们一切都好。

我在过去的两天里一直在尝试编写一个国际象棋引擎，但我遇到了一个似乎无法解决的问题。我有下面的代码，它完美地工作，棋子可以在棋盘上的所有2D空间中对角线移动（请注意，棋盘是一个8x8的2D数组），但问题是我不知道如何阻止棋子在对角线移动时跳过其他棋子。

这是这个方法：

  1. /**
  2.  * y = abs(x)
  3.  * y = -abs(x)
  4.  * 编写这两个函数将允许棋子在所有方向上对角线移动。
  5.  *@param pieceX: 棋子的当前X坐标
  6.  * @param pieceY : 棋子的当前Y坐标
  7.  * @param board: Board实例，用于获取所有棋子的位置
  8.  * @return 合法的移动
  9.  */
  10. protected int[][] diagonalMove(int pieceX, int pieceY, Board board)
  11. {
  12.     ArrayList<Integer> legalXMovements = new ArrayList<>();
  13.     ArrayList<Integer> legalYMovements = new ArrayList<>();
  15.     // 8x8大小的笛卡尔平面。
  16.     for (int x = 7; x > -8; x--)
  17.     {
  18.         for (int y = 7; y > -8; y--)
  19.         {
  20.             // 函数1：y = abs(x) 且 y > 0: Math.abs(x) == Math.abs(y)
  21.             // 函数2：y = -abs(x) : y == -Math.abs(x)
  22.             if (Math.abs(x) == Math.abs(y) || y == -Math.abs(x))
  23.             {
  24.                 // 防止越界。
  25.                 if (pieceX + x >= 0 && pieceX + x < 8)
  26.                 {
  27.                     if (pieceY + y >= 0 && pieceY + y < 8)
  28.                     {
  29.                         // 确保棋子不吃掉己方的棋子
  31.                         // 如果格子为空。
  32.                         if (board.getTile(pieceX + x, pieceY + y).checkIsEmpty())
  33.                         {
  34.                             legalXMovements.add(pieceX + x);
  35.                             legalYMovements.add(pieceY + y);
  36.                         }
  37.                         else
  38.                         {
  39.                             // 如果是敌人。
  40.                             if (color != board.getTile(pieceX + x, pieceY + y).getPiece().getColor())
  41.                             {
  42.                                 legalXMovements.add(pieceX + x);
  43.                                 legalYMovements.add(pieceY + y);
  44.                             }
  45.                         }
  47.                     }
  48.                 }
  49.             }
  50.         }
  51.     }
  52.     // 国际象棋，防止棋子在对角线移动时跳过其他棋子
  53.     int[][] finalLegalMovements = new int[legalXMovements.size()][2];
  54.     for (int x = 0; x < legalXMovements.size(); x++)
  55.     {
  56.         finalLegalMovements[x][0] = legalXMovements.get(x);
  57.         finalLegalMovements[x][1] = legalYMovements.get(x);
  58.     }
  60.     return finalLegalMovements;
  61. }

感谢你的帮助！

英文:

hope you guys are doing fine.

I've been trying to code a chess engine in the last two days, i have problem i can't seem to solve, i have this code below that works perfecally fine, the piece goes diagonally in all the 2D space limited in the board (note that the board is an 8*8 2D array), the problem is i can't figure out how to prevent a piece from jumping over other pieces when going diagonally

here is the method:

  1.     /**
  2. * y = abs(x)
  3. * y = -abs(x)
  4. * programming these 2 functions will let the piece go diagonally in all directions.
  5. *@param pieceX: current X coordinates of the piece
  6. * @param pieceY : current Y Coordinates of the piece
  7. * @param board: Board instance to get the locations of all the pieces
  8. * @return legal movements
  9. */
  10. protected int[][] diagonalMove(int pieceX, int pieceY, Board board)
  11. {
  12. ArrayList&lt;Integer&gt; legalXMovements = new ArrayList&lt;&gt;();
  13. ArrayList&lt;Integer&gt; legalYMovements = new ArrayList&lt;&gt;();
  14. //cartesian plane with a size of 8*8.
  15. for (int x = 7; x &gt; -8; x--)
  16. {
  17. for (int y = 7; y &gt; -8; y--)
  18. {
  19. //function 1: y = abs(x) and y &gt; 0: Math.abs(x) == Math.abs(y)
  20. //function 2: y = -abs(x) : y == -Math.abs(x)
  21. if (Math.abs(x) == Math.abs(y) || y == -Math.abs(x))
  22. {
  23. //prevent OutOfBounds at any case.
  24. if (pieceX + x &gt;= 0 &amp;&amp; pieceX + x &lt; 8)
  25. {
  26. if (pieceY + y &gt;= 0 &amp;&amp; pieceY + y &lt; 8)
  27. {
  28. //make sure that the piece doesn&#39;t eat his allies
  29. //if Tile is empty.
  30. if (board.getTile(pieceX + x, pieceY + y).checkIsEmpty())
  31. {
  32. legalXMovements.add(pieceX + x);
  33. legalYMovements.add(pieceY + y);
  34. }
  35. else
  36. {
  37. //if enemy.
  38. if (color != board.getTile(pieceX + x, pieceY + y).getPiece().getColor())
  39. {
  40. legalXMovements.add(pieceX + x);
  41. legalYMovements.add(pieceY + y);
  42. }
  43. }
  44. }
  45. }
  46. }
  47. }
  48. }
  49. //Chess, preventing a piece from jumping over pieces when going diagonally
  50. int[][] finalLegalMovements = new int[legalXMovements.size()][2];
  51. for (int x = 0; x &lt; legalXMovements.size(); x++)
  52. {
  53. finalLegalMovements[x][0] = legalXMovements.get(x);
  54. finalLegalMovements[x][1] = legalYMovements.get(x);
  55. }
  56. return finalLegalMovements;
  57. }

Thanks for helping!

output:
国际象棋，防止棋子在斜向移动时跳过其他棋子。

答案1

得分: 1

这是我以前写的一小段代码，它运行得很好，但与你的架构不同。无论如何，它可能会帮助你提出自己的解决方案。

  1. else if((piece == 'B') || (piece == 'b')){
  2.     
  3.     //检查deltaX和deltaY是否相等
  4.     if(Math.abs(move.getFromX()-move.getToX()) == Math.abs(move.getFromY() - move.getToY())){
  5.         //检查方向
  6.         int directionX = 1;
  7.         if(move.getToX() < move.getFromX())
  8.             directionX = -1;
  9.         
  10.         int directionY = 1;
  11.         if(move.getToY() < move.getFromY())
  12.             directionY = -1;
  13.         
  14.         //检查是否所有位置都为空
  15.         int y = move.getFromY();
  16.         for(int x = move.getFromX() + directionX; x != move.getToX(); x += directionX){
  17.             y += directionY;
  18.             
  19.             if(position.getPieceAt(x, y) != ' ')
  20.                 //有棋子阻挡 -> 移动非法!
  21.                 return false;
  22.             
  23.         }
  24.         
  25.     }
  26.     else{
  27.         return false;
  28.     }
  29. }

请注意，我是在2009年写的这段代码，它不是很好的代码，结构可以更好地组织，并且存在风格问题。但数学部分是可靠的。

英文:

Here is a bit of code I once wrote, which works just fine, but uses a different architecture from yours. Anyway, it might help you come up with your own solution.

  1. 	else if((piece == &#39;B&#39;) || (piece == &#39;b&#39;)){
  2. //Check if deltaX and deltaY are equal
  3. if(Math.abs(move.getFromX()-move.getToX()) == Math.abs(move.getFromY() - move.getToY())){
  4. //check the directions
  5. int directionX = 1;
  6. if(move.getToX() &lt; move.getFromX())
  7. directionX = -1;
  8. int directionY = 1;
  9. if(move.getToY() &lt; move.getFromY())
  10. directionY = -1;
  11. // Check if everything is free
  12. int y = move.getFromY();
  13. for(int x = move.getFromX() + directionX; x != move.getToX(); x += directionX){
  14. y += directionY;
  15. if(position.getPieceAt(x, y) != &#39; &#39;)
  16. //A piece is in the way -&gt; move illegal!
  17. return false;
  18. }
  19. }
  20. else{
  21. return false;
  22. }
  23. }

Note that I wrote this in 2009, it is not good code, it could be structured far better and has stylistic problems. But the maths are solid.

huangapple
  • 本文由 发表于 2020年8月7日 23:47:48
  • 转载请务必保留本文链接：https://go.coder-hub.com/63305161.html
  • chess
  • java
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定