Java棋盘边框？

Question

我有点卡住了试图为我的棋盘做一个边框，从上到下 8-1，从左到右啊。我不太确定该怎么做。非常感谢建议和帮助！干杯:)

当前输出为：

BR BKn BB BK BQ BB BKn BR
BP BP BP BP BP BP BP BP

WP WP WP WP WP WP WP
WR WKn WB WK WQ WB WKn WR

下面是 Java 代码：

public class ex5 {
public enum Chessmen {
    WHITE_KING,
    WHITE_QUEEN,
    WHITE_ROOK,
    WHITE_BISHOP,
    WHITE_KNIGHT,
    WHITE_PAWN,
    BLACK_KING,
    BLACK_QUEEN,
    BLACK_ROOK,
    BLACK_BISHOP,
    BLACK_KNIGHT,
    BLACK_PAWN,
    EMPTY
}
public static void printBoard (Chessmen [][] chessboard){
    for (int i=0; i<chessboard.length;i++){
        for (int j = 0; j<chessboard.length;j++){
            switch (chessboard [i][j]){
            case WHITE_KING:
                System.out.print("WK\t");
                break;
            case WHITE_QUEEN:
                System.out.print("WQ\t");
                break;
            case WHITE_ROOK:
                System.out.print("WR\t");
                break;
            case WHITE_BISHOP:
                System.out.print("WB\t");
                break;
            case WHITE_KNIGHT:
                System.out.print("WKn\t");
                break;
            case WHITE_PAWN:
                System.out.print("WP\t");
                break;
            case BLACK_KING:
                System.out.print("BK\t");
                break;
            case BLACK_QUEEN:
                System.out.print("BQ\t");
                break;
            case BLACK_ROOK:
                System.out.print("BR\t");
                break;
            case BLACK_BISHOP:
                System.out.print("BB\t");
                break;
            case BLACK_KNIGHT:
                System.out.print("BKn\t");
                break;
            case BLACK_PAWN:
                System.out.print("BP\t");
                break;
            default:
                System.out.print(" " + "\t");
                break;
            }
        }
        System.out.println("");
    }
}



public static void main(String[] args) {
    int Rows = 8;
    int Columns = 8;
    Chessmen [][] chessboard = new Chessmen [Rows][Columns];
    for (int i=0;i<chessboard.length; i++){
        for (int j=0;j<chessboard[0].length;j++){
            if (i==1){
                chessboard [i][j]= Chessmen.BLACK_PAWN;
            }else if (i==6){
                chessboard [i][j]= Chessmen.WHITE_PAWN;
            }else if ((i==0&&j==7)||(i==0&&j==0)){
                chessboard [i][j]= Chessmen.BLACK_ROOK;
            }else if ((i==0&&j==1)||(i==0&&j==6)){
                chessboard [i][j] = Chessmen.BLACK_KNIGHT;
            }else if ((i==0&&j==2)||(i==0&&j==5)){
                chessboard [i][j] = Chessmen.BLACK_BISHOP;
            }else if (i==0&&j==3){
                chessboard [i][j] = Chessmen.BLACK_KING;
            }else if (i==0&&j==4){
                chessboard [i][j] = Chessmen.BLACK_QUEEN;
            }else if ((i==7&&j==0)||(i==7&&j==7)){
                chessboard [i][j]= Chessmen.WHITE_ROOK;
            }else if ((i==7&&j==1)||(i==7&&j==6)){
                chessboard [i][j] = Chessmen.WHITE_KNIGHT;
            }else if ((i==7&&j==2)||(i==7&&j==5)){
                chessboard [i][j] = Chessmen.WHITE_BISHOP;
            }else if (i==7&&j==3){
                chessboard [i][j] = Chessmen.WHITE_KING;
            }else if (i==7&&j==4){
                chessboard [i][j] = Chessmen.WHITE_QUEEN;
        }else {
                chessboard [i][j]= Chessmen.EMPTY;
            }

        }   

    }
        printBoard (chessboard);

}
}

Answer 1

调用 System.out.println("+--------------------------------+") 外部渲染循环之前和之后。

在内部渲染循环之前和之后调用 System.out.print("|")。

你需要稍微调整一下。

Answer 2

正如其他人所说，您需要在一行上显示空行和空方块。另外，您需要为每个方格打印相同数量的字符，因此我建议您使用 BN 表示黑夜，使用 BK 表示黑王。 N在代数国际象棋符号中用来表示马，以区别于国王。

由于我已经用 C++ 解决了这个问题，所以我将在下面发布我的代码。您可以使用它作为一种算法来将其翻译成 Java。它将显示这样的面板：

  (Coups reversibles : 0)
  +-X-+---+---+---+---+---+---+-X-+
8 |=R=|=N=|=B=|=Q=|=K=|=B=|=N=|=R=|
  +---+---+---+---+---+---+---+---+
7 |=P=|=P=|=P=|=P=|=P=|=P=|=P=|=P=|
  +---+---+---+---+---+---+---+---+
6 |   | . |   | . |   | . |   | . |
  +---+---+---+---+---+---+---+---+
5 | . |   | . |   | . |   | . |   |
  +---+---+---+---+---+---+---+---+
4 |   | . |   | . |   | . |   | . |
  +---+---+---+---+---+---+---+---+
3 | . |   | . |   | . |   | . |   |
  +---+---+---+---+---+---+---+---+
2 | P | P | P | P | P | P | P | P |
  +---+---+---+---+---+---+---+---+
1 | R | N | B | Q | K | B | N | R |
=>+-X-+---+---+---+---+---+---+-X-+
    a   b   c   d   e   f   g   h

我认为它有一些有趣的功能。没有碎片的黑色正方形的中心有一个点。棋盘底部或顶部的箭头告诉用户下一步要移动哪一侧。一个“X”或者没有它告诉你车是否可以城堡。列下方的箭头“^”表示该列中的棋子可以被“en passant”拿走。

所以这里是代码（可能有错误，我刚刚翻译了法语中的标识符和注释，没有再次编译）：

///////////////////////////////////////////////////////////////////////////
   std::ostream& operator << (std::ostream& out, const CPlanche& planche)
   {
      static const string piecesNames[] = {"   ","   ",
                                            " P ","=P=",
                                            " N ","=N=",
                                            " K ","=K=",
                                            "   ","   ",
                                            " B ","=B=",
                                            " R ","=R=",
                                            " Q ","=Q="};

      // We display how many revirsable moves have been playes
      out <<"  (Coups reversibles : " <<board.RecersiblesMoves() <<")\n";

      // If it's black to move we display an arrow
      if (board.ColorToMove() == BLACK)
      {
         out <<"=>";
      }
      else
      {
         out <<"  ";
      }

      // We display the top line
      out <<"+-" <<(Board.Castling(Black, QueenSideCastling)?'X':'-') <<"-+---+---+---+---+---+---+-" <<(board.Castling(Black, LingSideCastling)?'X':'-') <<"-+\n";

      // We display all 8 lines
      for (int line = 0; line < 8; line++)
      {
        out <<(char)('8' - line) <<' ';

        // for each column
        for (int column = 0; column < 8; column++)
        {
          out <<'|';

          if (board[56 - 8 * line + column] != EMPTY)
          {
             out <<piecesNames[board[56 - 8 * iLigne + column]];
          }
          else
          {
            // If both the line and column are even OR if both are odds
            if (!((line | column) & 1) || (line & column & 1))
            {
               out <<"   ";
            }
            else
            {
               out <<" . ";
            }
          }
        }

        out <<"|\n";

        if (line != 7)
        {
          out <<"  +---+---+---+---+---+---+---+---+\n";
        }
      }

      // If it's white to move we display an arrow
      if (board.ColorToMove() == WHITE)
      {
         out <<"=>";
      }
      else
      {
         out <<"  ";
      }

      // We display the bottom line
      out <<"+-" <<(planche.Castling(WHITE, CastlingQueenSide)?'X':'-') <<"-+---+---+---+---+---+---+-" <<(Board.Castling(WHITE, CastlingKingSide)?'X':'-') <<"-+\n";

      // Whe display the arrow for the prise en passant if there is one.
      if (board.ColumnPriseEnPassant() != NO_PRISE_EN_PASSANT)
      {
         for (int i = 0; i < (board.ColumnPriseEnPassant() + 1); i++)
         {
            out <<"    ";
         }
         out <<"^\n";
      }

      // We display the columns letters
      out <<"    a   b   c   d   e   f   g   h\n";

      return out;
   }

我希望这会有所帮助。

议员

Answer 3

[编辑]
为了回应你的评论......

我认为你想要的实际上是一个 10x10 网格，你需要调整你的逻辑，只将游戏区域打印为 10x10 内的 8x8 并使用外部正方形（不包括角）打印您的字母和数字。
[结束编辑]

你的默认值不是空的，它只是什么都没有。 ，您将看到所有空白

抓住开关中的 EMPTY 情况并打印选项卡，换句话说

case BLACK_PAWN:
            System.out.print("BP\t");
            break;
        default:
            System.out.print(" " + "\t");
            break;
        }

，而不是您想要的：

case BLACK_PAWN:
            System.out.print("BP\t");
            break;
        case EMPTY:
            System.out.print(" " + "\t");
            break;
        }

Answer 4

我为 Java 中的 N 个皇后问题做了这个。因此，如果您尝试打印皇后之外的其他部件，请相应地定制您的代码。如果您不熟悉这个问题，那么挑战就是将 N 个皇后放在 N x N 棋盘上，使得没有两个皇后互相检查。我知道这是您发布问题多年后的事，但我想我应该将代码片段放在这里以供将来的人使用。

无论如何，第一步是创建 N x N 数组，表示棋盘上的空间以及棋盘上当前棋子的值。值得注意的是，由于这是 Java，我们的板是基于 0 的（因为每行中的空格编号为 0 到 7，而不是 1 到 8）：

public static final int N = 8;
public static char [][] board = new char[N][N];
//initialize every space to a space
for(int i = 0; i < N; i++){
    for(int j = 0; j < N; j++){
        board[i][j] = ' ';
    }
}

请参阅我们将每个点初始化为一个空格，以便我们可以迭代通过我对皇后位置的矢量，只改变需要放置皇后的位置。

以下是解决方案的示例向量：[1 6 2 5 7 4 0 3]。假设该向量由 int[] vector = new int[N] 表示。元素数量等于棋盘中的行数。它在向量中的索引对应于行，而值本身对应于皇后在该行中的列号。因此，我们只需循环这些并相应地更新棋盘数组：

for(int j = 0; j < N; j++){
    board[j][vector[j]] = 'Q';
}

如果您的问题涉及实际的国际象棋游戏，您将需要迭代每个棋子并以类似的方式更新其棋盘位置。

在我解释如何制作这个板之前，让我向您展示与前面提到的向量相对应的板。顺便说一句，注意没有皇后检查！我用遗传算法解决了这个问题。

+---+---+---+---+---+---+---+---+
|   | Q |   |   |   |   |   |   | 
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   | Q |   | 
+---+---+---+---+---+---+---+---+
|   |   | Q |   |   |   |   |   | 
+---+---+---+---+---+---+---+---+
|   |   |   |   |   | Q |   |   | 
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   | Q | 
+---+---+---+---+---+---+---+---+
|   |   |   |   | Q |   |   |   | 
+---+---+---+---+---+---+---+---+
| Q |   |   |   |   |   |   |   | 
+---+---+---+---+---+---+---+---+
|   |   |   | Q |   |   |   |   | 
+---+---+---+---+---+---+---+---+

我们的下一步是在行之间（以及顶部和底部）创建边框。我将每一行视为格式化字符串。由于我们有空间行和边框行，因此行数组的大小为 2 * N + 1。

String[] row = new String[2*N + 1];
String border = "";
//must be the length of board
for(int i = 0; i < N; i++){
    border += "+---";
}
border += "+";
//every other row is a border row
for(int i = 0; i < 2*N +1; i+=2){
    row[i] = border;
}
//must include the bottom
row[2*N] = border;

接下来，我们为棋盘空间本身创建字符串。由于我们的 board[][] 中已经有这些，我们只需要格式化。

for(int i = 0; i < N; i++){
    //left bar
    String spaces = "| ";
    //place enclosing right bar and spaces so next char goes in middle of next space
    for(int j = 0; j < N; j++){
        spaces += board[i][j];
        spaces += " | ";
    }
    //add the spaces string to the rows at the odd indices
    row[2*k +1 ] = spaces;

}

剩下的就是打印该板。

for(int i = 0; i < 2*N +1; i++){
    System.out.println(row[i]);
}

希望这对某人有帮助！