Java шахматная доска границы? - PullRequest
1 голос
/ 05 октября 2011

Я застрял, пытаясь сделать границу для моей шахматной доски, бегая сверху вниз 8-1 и слева направо ах.Я не совсем уверен, как это сделать.Советы и помощь очень ценятся!Приветствия:)

В настоящее время вывод:

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

WP WP WP WP WP WP WP WP
WR WKn WB WK WQ WB WK WK 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);

}
}

Ответы [ 4 ]

2 голосов
/ 07 октября 2011

Как уже сказал другой, вам нужно отобразить пустые строки и пустые квадраты на строке. Кроме того, вам нужно напечатать одинаковое количество символов для каждого квадрата, поэтому я предлагаю вам использовать 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

Имеет, я думаю, некоторые интересные особенности. Черный квадрат без фигуры имеет точку в центре. Стрелка внизу на доске или вверху указывает пользователю, какой стороной следует двигаться дальше. «Х» или его отсутствие говорит вам, может ли ладья рокировать. Стрелка «^» под столбцом указывает, что пешка в указанном столбце может быть взята «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;
   }

Надеюсь, это поможет.

тр

2 голосов
/ 05 октября 2011

вызов System.out.println("+--------------------------------+") до и после внешнего цикла рендеринга.

вызов System.out.print("|") до и после внутреннего цикла рендеринга.

Вам нужно немного его настроить.

0 голосов
/ 20 марта 2014

Я сделал это для проблемы N королев в Java.Итак, если вы пытаетесь напечатать другие фрагменты, кроме королевы, то соответствующим образом настройте свой код.Если вы не знакомы с этой проблемой, то задача состоит в том, чтобы разместить 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;

Далее мы создаем строки для самих пространств доски.Так как они уже есть на нашей доске [] [], нам нужно только отформатировать.

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]);
}

Надеюсь, это кому-нибудь поможет!

0 голосов
/ 05 октября 2011

[EDIT] В ответ на ваш комментарий ...

Я думаю, что на самом деле вам нужна сетка 10x10, и вам нужно настроить логику так, чтобы печатать игровую область как 8x8 внутри 10x10, и использовать внешние квадраты (не включая углы) для печати ваших писем и номера. [КОНЕЦ РЕДАКТИРОВАНИЯ]

по умолчанию вы не ПУСТОЙ, просто ничего. поймайте ПУСТОЙ кейс в вашем коммутаторе и распечатайте вкладку, и вы увидите все пустые места

другими словами, вместо

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;
        }
...