شطرنچ

Question

شطرنچ

سوال

سلام

بازی شطرنج رو با زبان سی پلاس پلاس دارین؟یا اینکه راهنمایین کنین بیس کلیش چطوریه راهنمایی کنین

ممنون

حل شد 1

زبان c++ 7 سال ۱۳۹۵/۱۲/۲۹ ۶:۵۴:۰۶ ۱۳۹۵/۱۲/۲۹ ۶:۵۴:۰۶ 1 پاسخ ها کاربر تازه 0

درباره zzکاربر تازه

پاسخ ( 1 )

ارسال یک پاسخ

پرسش قبلی

پرسش بعدی

SOLTANE GHALBHA مدیر سایت · Accepted Answer · ۱۳۹۵/۱۲/۲۹ ۱۷:۴۴:۱۲

سلام

خدمت شما، نمونه سورس شطرنج به زبان ++C:

    /*
     * This is a small and simple chessgame to be played by two human players.
     * Copyright 2011 Emil Kampp <beporsam.ir> Email:<beporsam@gmail.com>.
     * 
     * TODO: Check for check- and mate situations.
     * 
     */
     
    #include "iostream"
    #include "fstream"
    #include "string"
    #include "vector"
    #include "math.h"
    #include "cstdlib"
    #include "sstream"
    using namespace std;
    using std::vector;
     
    // Contains the current board
    int board[8][8];
     
    // Contains a list of the pieces that has been taken out
    string taken_pieces = "";
     
    // Reference ids for the pieces
    const int pawn    = 1;
    const int rock    = 2;
    const int knight  = 3;
    const int bishop  = 4;
    const int queen   = 5;
    const int king    = 6;
     
    // Current state of the game
    int status = 0;
     
    // Current state of the application
    int exit_game = 0;
     
    // Current turn
    int current_player = 1;
     
    // Number of played rounds in this game
    int turn_counter = 1;
     
    /*
     * Resets the board
     * 
     * This takes no arguments and resets all the positions of the pieces to a 
     * prestine version of the game.
     * 
     */
    void reset(){
      // Normal board setup
      board[0][0]=rock;
      board[0][1]=knight;
      board[0][2]=bishop;
      board[0][3]=queen;
      board[0][4]=king;
      board[0][5]=bishop;
      board[0][6]=knight;
      board[0][7]=rock;
      board[1][0]=pawn;
      board[1][1]=pawn;
      board[1][2]=pawn;
      board[1][3]=pawn;
      board[1][4]=pawn;
      board[1][5]=pawn;
      board[1][6]=pawn;
      board[1][7]=pawn;
      board[2][0]=0;
      board[2][1]=0;
      board[2][2]=0;
      board[2][3]=0;
      board[2][4]=0;
      board[2][5]=0;
      board[2][6]=0;
      board[2][7]=0;
      board[3][0]=0;
      board[3][1]=0;
      board[3][2]=0;
      board[3][3]=0;
      board[3][4]=0;
      board[3][5]=0;
      board[3][6]=0;
      board[3][7]=0;
      board[4][0]=0;
      board[4][1]=0;
      board[4][2]=0;
      board[4][3]=0;
      board[4][4]=0;
      board[4][5]=0;
      board[4][6]=0;
      board[4][7]=0;
      board[5][0]=0;
      board[5][1]=0;
      board[5][2]=0;
      board[5][3]=0;
      board[5][4]=0;
      board[5][5]=0;
      board[5][6]=0;
      board[5][7]=0;
      board[6][0]=-pawn;
      board[6][1]=-pawn;
      board[6][2]=-pawn;
      board[6][3]=-pawn;
      board[6][4]=-pawn;
      board[6][5]=-pawn;
      board[6][6]=-pawn;
      board[6][7]=-pawn;
      board[7][0]=-rock;
      board[7][1]=-knight;
      board[7][2]=-bishop;
      board[7][3]=-queen;
      board[7][4]=-king;
      board[7][5]=-bishop;
      board[7][6]=-knight;
      board[7][7]=-rock;
      current_player = 1;
      turn_counter = 1;
      status = 0;
      taken_pieces = "";
    }
     
    /*
     * Returns the +current_player+ integer for the opposite player
     * 
     */
    int oppositePlayer(){
      if(current_player == 1) return 2;
      return 1;
    }
     
    /*
     * Returns the +current_player+ integer for the current player
     * 
     */
    string currentPlayerColor(){
      if(current_player == 1) return "White";
      return "Black";
    }
     
    /*
     * Returns the color of the +current_player+
     * 
     */
    string oppositePlayerColor(){
      if(current_player == 1) return "Black";
      return "White";
    }
     
    /*
     * Constructs a text-representation of the given +piece+.
     * 
     * All whitespaces can be supressed with the +supress_blank+ option.
     * 
     */
    string displayPiece(int piece=0, int supress_blank=0){
      string str = "";
      if(piece > 0){ // White piece
        if(supress_blank==1){
          switch(piece){
            case rock:    str = "r"; break;
            case knight:  str = "k"; break;
            case bishop:  str = "b"; break;
            case queen:   str = "Q"; break;
            case king:    str = "K"; break;
            case pawn:    str = "p"; break;
          }
        } else {
          switch(piece){
            case rock:    str = " r "; break;
            case knight:  str = " k "; break;
            case bishop:  str = " b "; break;
            case queen:   str = " Q "; break;
            case king:    str = " K "; break;
            case pawn:    str = " p "; break;
          }
        }
      } else {
        if(piece < 0) {
          switch(-piece){
            case rock:    str = "(r)"; break;
            case knight:  str = "(k)"; break;
            case bishop:  str = "(b)"; break;
            case queen:   str = "(Q)"; break;
            case king:    str = "(K)"; break;
            case pawn:    str = "(p)"; break;
          }
        } else {
          if(supress_blank == 1) return "";
          str = "   ";
        }
      }
      return str;
    }
     
    /*
     * Generates a human readable list of all the pieces that has been taken 
     * during the game.
     * 
     */
    string takenPiecesList(){
      string list = taken_pieces;
      if(list.length()==0) list = "N/A";
      return list;
    }
     
    /*
     * Ouputs a graphical represntation of the +board+ array to the CLI
     * 
     */
    void displayBoard(){
      cout << "\n\n";
      cout << "    a   b   c   d   e   f   g   h\n";
      cout << "  +-------------------------------+\n";
      for(size_t i = 0; i < 8; ++i){
        switch(i){
          case 0: cout << "1 "; break;
          case 1: cout << "2 "; break;
          case 2: cout << "3 "; break;
          case 3: cout << "4 "; break;
          case 4: cout << "5 "; break;
          case 5: cout << "6 "; break;
          case 6: cout << "7 "; break;
          case 7: cout << "8 "; break;
        }
        cout << "|";
        for(size_t j = 0; j < 8; ++j){
          cout << displayPiece(board[i][j]);
          cout << "|";
          if(j == 7) cout << "\n";
        }
        cout << "  +-------------------------------+\n";
      }
      cout << "Taken pieces: " << takenPiecesList() << "\n";
    }
     
    /*
     * Checks if the given move is valid.
     * 
     * The check is based on the originating coordinates and the targeted 
     * coordinates.
     * 
     */
    int validMove(int ox, int oy, int dx, int dy){
      int source = board[oy][ox];
      int target = board[dy][dx];
      // cout << "Validating move for " << displayPiece(source) << "@" << ox << "," << oy 
      //      << " to " << target << "@" << dx << "," << dy << "\n";
      switch(abs(source)){
        //Pawn
        case 1: case -1:
        if(dx==ox && abs(dy-oy)==1 && target==0) return 1;
        if(abs(dx-ox)==1 && abs(dy-oy)==1 && target!= 0) return 1;
        if(current_player == 1 && oy==1 && abs(oy-dy)==2 && target == 0) return 1;
        if(current_player == 2 && oy==6 && abs(oy-dy)==2 && target == 0) return 1;
        // TODO: Check for en-passant
        break;
     
        // Rock
        case 2:
        if(dx==ox){ // Moving vertically
          if(dy>oy){ // Downards
            for(size_t row = (unsigned)(oy+1); row < (unsigned)dy; ++row){
              if(board[row][dx] != 0) return 0;
            }
          } else { // Upwards
            for(size_t row = (unsigned)dy; row < (unsigned)(oy-1); ++row){
              if(board[row][dx] != 0) return 0;
            }
          }
          return 1;
        }
        if(dy==oy){ // Moving horizontally
          if(dx>ox){ // Rightwards
            for(size_t column = (unsigned)(ox+1); column < (unsigned)dy; ++column){
              if(board[dy][column] != 0) return 0;
            }
          }
          if(dx<ox){ // Leftwards
            for(size_t column = (unsigned)dx; column < (unsigned)(ox-1); ++column){
              if(board[dy][column] != 0) return 0;
            }
          }
          return 1;
        }
        return 0;
        break;
     
        // Knight
        case 3:
        if((abs(dy-oy)==2 && abs(dx-ox)==1) || (abs(dx-ox)==2 && abs(dy-oy)==1)){
          return 1;
        }
        return 0;
        break;
     
        // Bishop
        case 4:
        if(abs(dy-oy) == abs(dx-ox)){ // Moving diagonally
          if(dy>oy){ // South
            int column = min(dx, ox)+1;
            for(size_t row = oy+1; row < (unsigned)dy; ++row){
              if(board[row][column] != 0) return 0;
              column ++;
            }
            return 1;
          }
          if(dy<oy && dx>ox){ // North
            int column = min(dx, ox)+1;
            for(size_t row = oy+1; row < (unsigned)dy; ++row){
              if(board[row][column] != 0) return 0;
              column ++;
            }
            return 1;
          }
        }
        return 0;
        break;
     
        // Queen
        case 5:
        if(abs(dy-oy) == abs(dx-ox)){ // Moving diagonally
          if(dy>oy){ // South
            int column = min(dx, ox)+1;
            for(size_t row = oy+1; row < (unsigned)dy; ++row){
              if(board[row][column] != 0) return 0;
              column ++;
            }
            return 1;
          }
          if(dy<oy && dx>ox){ // North
            int column = min(dx, ox)+1;
            for(size_t row = oy+1; row < (unsigned)dy; ++row){
              if(board[row][column] != 0) return 0;
              column ++;
            }
            return 1;
          }
        }
        if(dy==oy || dx==ox){ // Moving straight
          if(dx==ox){ // Moving vertically
            if(dy>oy){ // Downards
              for(size_t row = (unsigned)(oy+1); row < (unsigned)dy; ++row){
                if(board[row][dx] != 0) return 0;
              }
            } else { // Upwards
              for(size_t row = (unsigned)dy; row < (unsigned)(oy-1); ++row){
                if(board[row][dx] != 0) return 0;
              }
            }
            return 1;
          }
          if(dy==oy){ // Moving horizontally
            if(dx>ox){ // Rightwards
              for(size_t column = (unsigned)(ox+1); column < (unsigned)dy; ++column){
                if(board[dy][column] != 0) return 0;
              }
            }
            if(dx<ox){ // Leftwards
              for(size_t column = (unsigned)dx; column < (unsigned)(ox-1); ++column){
                if(board[dy][column] != 0) return 0;
              }
            }
            return 1;
          }
        }
        return 0;
        break;
     
        // King
        case 6:
        if(abs(dy-oy)<=1 && abs(dx-ox)<=1) return 1;
        // TODO: Check for castling
        return 0;
        break;
      }
      return 0;
    }
     
    /*
     * Logs the given +piece+ into the +taken_pieces+ list.
     * 
     */
    void logTakenPiece(int piece){
      string piece_str = displayPiece(piece, 1);
      if(piece_str.length()>0){
        if(taken_pieces.length()>0) taken_pieces=taken_pieces+",";
        taken_pieces=taken_pieces+displayPiece(piece);
      }
    }
     
    /*
     * Displays the help message
     * 
     * TODO: Move the help message into the help.txt file.
     * 
     */
    void displayHelp(){
      cout << "\n\n";
      cout << "When asked for a move, please enter a move in the following fasion: from>to. This means, that if you want to move from a1 to a2 then you should write a1>a2.\n";
      cout << "If you get the warning: Illegal move it means that you entered a move that's either impossible with the selected piece or you't trying to take one of your own pieces or you'r trying to move out of the board.\n";
      cout << "Typing reset will reset the game back to starting position. Typing display will redraw the board. Typing exit or quit will exit the game.\n";
    }
     
    /*
     * Gets a letter (a..h) from a number (1..8)
     * 
     */
    string getLetter(int column){
      switch(column){
        case 0: return "a"; break;
        case 1: return "b"; break;
        case 2: return "c"; break;
        case 3: return "d"; break;
        case 4: return "e"; break;
        case 5: return "f"; break;
        case 6: return "g"; break;
      }
      return "n/a";
    }
     
    /*
     * Converts a given letter (a..h) into a corresponding number (1..8)
     * 
     */
    int getNumber(string letter){
      if(letter == "a") return 0;
      if(letter == "b") return 1;
      if(letter == "c") return 2;
      if(letter == "d") return 3;
      if(letter == "e") return 4;
      if(letter == "f") return 5;
      if(letter == "g") return 6;
      if(letter == "h") return 7;
      return 0;
    }
     
    /*
     * Catches the users inputted move
     * 
     * This also does some validation of the move..
     * DISCUSS: Should all validation be moved somewhere else?
     * 
     */
    int getMove(){
      cout << "Turn " << turn_counter << ". " << currentPlayerColor() <<", select a move:";
      string move = "";
      cin >> move;
     
      // Checks if the move is a command
      if(move == "help"){ // Display help
        displayHelp();
        displayBoard();
        return 0;
      }
      if(move == "reset"){ // Reset the game
        reset(); displayBoard(); return 0;
      }
      if(move == "display"){ // Displays the board
        displayBoard(); return 0;
      }
      if(move == "exit" || move == "quit") exit(1);
     
      // Splits the move into orgination and destrination and those 
      // into x and y parts
      // TODO: Add validation of the y-coordinate of both the 
      //       destination and the origination. 
      int ox = 0; int oy = 0; int dx = 0; int dy = 0;
      string ox_part = move.substr(0, move.find(">")).substr(0, 1);
      string oy_part = move.substr(0, move.find(">")).substr(1, 1);
      string dx_part = move.substr(move.find(">")+1, move.length()).substr(0, 1);
      string dy_part = move.substr(move.find(">")+1, move.length()).substr(1, 1);
      ox = getNumber(ox_part);
      oy = atoi(oy_part.c_str())-1;
      dx = getNumber(dx_part);
      dy = atoi(dy_part.c_str())-1;
     
      // Gets the piece in question and moves it
      int source = board[oy][ox];
      int target = board[dy][dx];
      if((current_player == 1 && (source <= 0 || target > 0)) || (current_player == 2 && (source >= 0 || target < 0)) || !validMove(ox, oy, dx, dy)){
        cout << "Illegal move\n"; return 0;
      }
     
      // Moves the piece
      board[oy][ox] = 0;
      board[dy][dx] = source;
      logTakenPiece(target);
     
      // Checks for win condition
      // Changes the +status+ for the game to the +current_player+
      if(abs(target) == king){
        status = current_player;
        return 0;
      }
     
      // Increments the +turn_counter+
      turn_counter ++;
     
      // Changes the turn
      current_player = oppositePlayer();
     
      // Redraws the board
      displayBoard();
     
      return 0;
    }
     
    /*
     * Displays the about.txt file content
     * 
     * TODO: Add the about.txt file
     * 
     */
    void displayGameInformation(){
      cout << "This is a game os chess to be played between to humans. To get help with movements and such, type 'help'.\n";
    }
     
    /*
     * Initializes the program and contains the main loop that keeps the game 
     * alive.
     * 
     */
    int main(){
      displayGameInformation();
      reset();
      displayBoard();
     
      while(exit_game == 0){
        while(status == 0){
          getMove();
        }
     
        // Displays win condition
        cout << currentPlayerColor() << " wins! Start a new game? [y/n]:";
        string new_game = "y";
        cin >> new_game;
        if(new_game == "y"){
          reset();
          displayBoard();
        } else {
          exit_game = 1;
        }
      }
     
      cout << "Thank you for playing.\n";
      return 0;
    }

۱

۲

۳

۴

۵

۶

۷

۸

۹

۱۰

۱۱

۱۲

۱۳

۱۴

۱۵

۱۶

۱۷

۱۸

۱۹

۲۰

۲۱

۲۲

۲۳

۲۴

۲۵

۲۶

۲۷

۲۸

۲۹

۳۰

۳۱

۳۲

۳۳

۳۴

۳۵

۳۶

۳۷

۳۸

۳۹

۴۰

۴۱

۴۲

۴۳

۴۴

۴۵

۴۶

۴۷

۴۸

۴۹

۵۰

۵۱

۵۲

۵۳

۵۴

۵۵

۵۶

۵۷

۵۸

۵۹

۶۰

۶۱

۶۲

۶۳

۶۴

۶۵

۶۶

۶۷

۶۸

۶۹

۷۰

۷۱

۷۲

۷۳

۷۴

۷۵

۷۶

۷۷

۷۸

۷۹

۸۰

۸۱

۸۲

۸۳

۸۴

۸۵

۸۶

۸۷

۸۸

۸۹

۹۰

۹۱

۹۲

۹۳

۹۴

۹۵

۹۶

۹۷

۹۸

۹۹

۱۰۰

۱۰۱

۱۰۲

۱۰۳

۱۰۴

۱۰۵

۱۰۶

۱۰۷

۱۰۸

۱۰۹

۱۱۰

۱۱۱

۱۱۲

۱۱۳

۱۱۴

۱۱۵

۱۱۶

۱۱۷

۱۱۸

۱۱۹

۱۲۰

۱۲۱

۱۲۲

۱۲۳

۱۲۴

۱۲۵

۱۲۶

۱۲۷

۱۲۸

۱۲۹

۱۳۰

۱۳۱

۱۳۲

۱۳۳

۱۳۴

۱۳۵

۱۳۶

۱۳۷

۱۳۸

۱۳۹

۱۴۰

۱۴۱

۱۴۲

۱۴۳

۱۴۴

۱۴۵

۱۴۶

۱۴۷

۱۴۸

۱۴۹

۱۵۰

۱۵۱

۱۵۲

۱۵۳

۱۵۴

۱۵۵

۱۵۶

۱۵۷

۱۵۸

۱۵۹

۱۶۰

۱۶۱

۱۶۲

۱۶۳

۱۶۴

۱۶۵

۱۶۶

۱۶۷

۱۶۸

۱۶۹

۱۷۰

۱۷۱

۱۷۲

۱۷۳

۱۷۴

۱۷۵

۱۷۶

۱۷۷

۱۷۸

۱۷۹

۱۸۰

۱۸۱

۱۸۲

۱۸۳

۱۸۴

۱۸۵

۱۸۶

۱۸۷

۱۸۸

۱۸۹

۱۹۰

۱۹۱

۱۹۲

۱۹۳

۱۹۴

۱۹۵

۱۹۶

۱۹۷

۱۹۸

۱۹۹

۲۰۰

۲۰۱

۲۰۲

۲۰۳

۲۰۴

۲۰۵

۲۰۶

۲۰۷

۲۰۸

۲۰۹

۲۱۰

۲۱۱

۲۱۲

۲۱۳

۲۱۴

۲۱۵

۲۱۶

۲۱۷

۲۱۸

۲۱۹

۲۲۰

۲۲۱

۲۲۲

۲۲۳

۲۲۴

۲۲۵

۲۲۶

۲۲۷

۲۲۸

۲۲۹

۲۳۰

۲۳۱

۲۳۲

۲۳۳

۲۳۴

۲۳۵

۲۳۶

۲۳۷

۲۳۸

۲۳۹

۲۴۰

۲۴۱

۲۴۲

۲۴۳

۲۴۴

۲۴۵

۲۴۶

۲۴۷

۲۴۸

۲۴۹

۲۵۰

۲۵۱

۲۵۲

۲۵۳

۲۵۴

۲۵۵

۲۵۶

۲۵۷

۲۵۸

۲۵۹

۲۶۰

۲۶۱

۲۶۲

۲۶۳

۲۶۴

۲۶۵

۲۶۶

۲۶۷

۲۶۸

۲۶۹

۲۷۰

۲۷۱

۲۷۲

۲۷۳

۲۷۴

۲۷۵

۲۷۶

۲۷۷

۲۷۸

۲۷۹

۲۸۰

۲۸۱

۲۸۲

۲۸۳

۲۸۴

۲۸۵

۲۸۶

۲۸۷

۲۸۸

۲۸۹

۲۹۰

۲۹۱

۲۹۲

۲۹۳

۲۹۴

۲۹۵

۲۹۶

۲۹۷

۲۹۸

۲۹۹

۳۰۰

۳۰۱

۳۰۲

۳۰۳

۳۰۴

۳۰۵

۳۰۶

۳۰۷

۳۰۸

۳۰۹

۳۱۰

۳۱۱

۳۱۲

۳۱۳

۳۱۴

۳۱۵

۳۱۶

۳۱۷

۳۱۸

۳۱۹

۳۲۰

۳۲۱

۳۲۲

۳۲۳

۳۲۴

۳۲۵

۳۲۶

۳۲۷

۳۲۸

۳۲۹

۳۳۰

۳۳۱

۳۳۲

۳۳۳

۳۳۴

۳۳۵

۳۳۶

۳۳۷

۳۳۸

۳۳۹

۳۴۰

۳۴۱

۳۴۲

۳۴۳

۳۴۴

۳۴۵

۳۴۶

۳۴۷

۳۴۸

۳۴۹

۳۵۰

۳۵۱

۳۵۲

۳۵۳

۳۵۴

۳۵۵

۳۵۶

۳۵۷

۳۵۸

۳۵۹

۳۶۰

۳۶۱

۳۶۲

۳۶۳

۳۶۴

۳۶۵

۳۶۶

۳۶۷

۳۶۸

۳۶۹

۳۷۰

۳۷۱

۳۷۲

۳۷۳

۳۷۴

۳۷۵

۳۷۶

۳۷۷

۳۷۸

۳۷۹

۳۸۰

۳۸۱

۳۸۲

۳۸۳

۳۸۴

۳۸۵

۳۸۶

۳۸۷

۳۸۸

۳۸۹

۳۹۰

۳۹۱

۳۹۲

۳۹۳

۳۹۴

۳۹۵

۳۹۶

۳۹۷

۳۹۸

۳۹۹

۴۰۰

۴۰۱

۴۰۲

۴۰۳

۴۰۴

۴۰۵

۴۰۶

۴۰۷

۴۰۸

۴۰۹

۴۱۰

۴۱۱

۴۱۲

۴۱۳

۴۱۴

۴۱۵

۴۱۶

۴۱۷

۴۱۸

۴۱۹

۴۲۰

۴۲۱

۴۲۲

۴۲۳

۴۲۴

۴۲۵

۴۲۶

۴۲۷

۴۲۸

۴۲۹

۴۳۰

۴۳۱

۴۳۲

۴۳۳

۴۳۴

۴۳۵

۴۳۶

۴۳۷

۴۳۸

۴۳۹

۴۴۰

۴۴۱

۴۴۲

۴۴۳

۴۴۴

۴۴۵

۴۴۶

۴۴۷

۴۴۸

۴۴۹

۴۵۰

۴۵۱

۴۵۲

۴۵۳

۴۵۴

۴۵۵

۴۵۶

۴۵۷

۴۵۸

۴۵۹

۴۶۰

۴۶۱

۴۶۲

۴۶۳

۴۶۴

۴۶۵

۴۶۶

۴۶۷

۴۶۸

۴۶۹

۴۷۰

۴۷۱

۴۷۲

۴۷۳

۴۷۴

۴۷۵

۴۷۶

۴۷۷

۴۷۸

۴۷۹

۴۸۰

۴۸۱

۴۸۲

۴۸۳

۴۸۴

۴۸۵

۴۸۶

۴۸۷

۴۸۸

۴۸۹

۴۹۰

۴۹۱

۴۹۲

۴۹۳

۴۹۴

۴۹۵

۴۹۶

۴۹۷

۴۹۸

۴۹۹

۵۰۰

۵۰۱

۵۰۲

۵۰۳

۵۰۴

۵۰۵

۵۰۶

۵۰۷

۵۰۸

۵۰۹

۵۱۰

۵۱۱

۵۱۲

۵۱۳

۵۱۴

۵۱۵

۵۱۶

۵۱۷

۵۱۸

۵۱۹

۵۲۰

۵۲۱

۵۲۲

۵۲۳

۵۲۴

۵۲۵

۵۲۶

۵۲۷

۵۲۸

۵۲۹

۵۳۰

۵۳۱

۵۳۲

۵۳۳

۵۳۴

۵۳۵

۵۳۶

۵۳۷

۵۳۸

۵۳۹

۵۴۰

۵۴۱

۵۴۲

۵۴۳

۵۴۴

۵۴۵

۵۴۶

۵۴۷

۵۴۸

۵۴۹

/*

* This is a small and simple chessgame to be played by two human players.

*

* TODO: Check for check- and mate situations.

*

*/

#include "iostream"

#include "fstream"

#include "string"

#include "vector"

#include "math.h"

#include "cstdlib"

#include "sstream"

using namespace std;

using std::vector;

// Contains the current board

int board[۸][۸];

// Contains a list of the pieces that has been taken out

string taken_pieces = "";

// Reference ids for the pieces

const int pawn = ۱;

const int rock = ۲;

const int knight = ۳;

const int bishop = ۴;

const int queen = ۵;

const int king = ۶;

// Current state of the game

int status = ۰;

// Current state of the application

int exit_game = ۰;

// Current turn

int current_player = ۱;

// Number of played rounds in this game

int turn_counter = ۱;

/*

* Resets the board

*

* This takes no arguments and resets all the positions of the pieces to a

* prestine version of the game.

*

*/

void reset(){

// Normal board setup

board[۰][۰]=rock;

board[۰][۱]=knight;

board[۰][۲]=bishop;

board[۰][۳]=queen;

board[۰][۴]=king;

board[۰][۵]=bishop;

board[۰][۶]=knight;

board[۰][۷]=rock;

board[۱][۰]=pawn;

board[۱][۱]=pawn;

board[۱][۲]=pawn;

board[۱][۳]=pawn;

board[۱][۴]=pawn;

board[۱][۵]=pawn;

board[۱][۶]=pawn;

board[۱][۷]=pawn;

board[۲][۰]=۰;

board[۲][۱]=۰;

board[۲][۲]=۰;

board[۲][۳]=۰;

board[۲][۴]=۰;

board[۲][۵]=۰;

board[۲][۶]=۰;

board[۲][۷]=۰;

board[۳][۰]=۰;

board[۳][۱]=۰;

board[۳][۲]=۰;

board[۳][۳]=۰;

board[۳][۴]=۰;

board[۳][۵]=۰;

board[۳][۶]=۰;

board[۳][۷]=۰;

board[۴][۰]=۰;

board[۴][۱]=۰;

board[۴][۲]=۰;

board[۴][۳]=۰;

board[۴][۴]=۰;

board[۴][۵]=۰;

board[۴][۶]=۰;

board[۴][۷]=۰;

board[۵][۰]=۰;

board[۵][۱]=۰;

board[۵][۲]=۰;

board[۵][۳]=۰;

board[۵][۴]=۰;

board[۵][۵]=۰;

board[۵][۶]=۰;

board[۵][۷]=۰;

board[۶][۰]=-pawn;

board[۶][۱]=-pawn;

board[۶][۲]=-pawn;

board[۶][۳]=-pawn;

board[۶][۴]=-pawn;

board[۶][۵]=-pawn;

board[۶][۶]=-pawn;

board[۶][۷]=-pawn;

board[۷][۰]=-rock;

board[۷][۱]=-knight;

board[۷][۲]=-bishop;

board[۷][۳]=-queen;

board[۷][۴]=-king;

board[۷][۵]=-bishop;

board[۷][۶]=-knight;

board[۷][۷]=-rock;

current_player = ۱;

turn_counter = ۱;

status = ۰;

taken_pieces = "";

}

/*

* Returns the +current_player+ integer for the opposite player

*

*/

int oppositePlayer(){

if(current_player == ۱) return ۲;

return ۱;

}

/*

* Returns the +current_player+ integer for the current player

*

*/

string currentPlayerColor(){

if(current_player == ۱) return "White";

return "Black";

}

/*

* Returns the color of the +current_player+

*

*/

string oppositePlayerColor(){

if(current_player == ۱) return "Black";

return "White";

}

/*

* Constructs a text-representation of the given +piece+.

*

* All whitespaces can be supressed with the +supress_blank+ option.

*

*/

string displayPiece(int piece=۰, int supress_blank=۰){

string str = "";

if(piece > ۰){ // White piece

if(supress_blank==۱){

switch(piece){

case rock: str = "r"; break;

case knight: str = "k"; break;

case bishop: str = "b"; break;

case queen: str = "Q"; break;

case king: str = "K"; break;

case pawn: str = "p"; break;

}

} else {

switch(piece){

case rock: str = " r "; break;

case knight: str = " k "; break;

case bishop: str = " b "; break;

case queen: str = " Q "; break;

case king: str = " K "; break;

case pawn: str = " p "; break;

}

} else {

if(piece < ۰) {

switch(-piece){

case rock: str = "(r)"; break;

case knight: str = "(k)"; break;

case bishop: str = "(b)"; break;

case queen: str = "(Q)"; break;

case king: str = "(K)"; break;

case pawn: str = "(p)"; break;

}

} else {

if(supress_blank == ۱) return "";

str = " ";

}

return str;

}

/*

* Generates a human readable list of all the pieces that has been taken

* during the game.

*

*/

string takenPiecesList(){

string list = taken_pieces;

if(list.length()==۰) list = "N/A";

return list;

}

/*

* Ouputs a graphical represntation of the +board+ array to the CLI

*

*/

void displayBoard(){

cout << "\n\n";

cout << " a b c d e f g h\n";

cout << " +-------------------------------+\n";

for(size_t i = ۰; i < ۸; ++i){

switch(i){

case ۰: cout << "۱ "; break;

case ۱: cout << "۲ "; break;

case ۲: cout << "۳ "; break;

case ۳: cout << "۴ "; break;

case ۴: cout << "۵ "; break;

case ۵: cout << "۶ "; break;

case ۶: cout << "۷ "; break;

case ۷: cout << "۸ "; break;

}

cout << "|";

for(size_t j = ۰; j < ۸; ++j){

cout << displayPiece(board[i][j]);

cout << "|";

if(j == ۷) cout << "\n";

}

cout << " +-------------------------------+\n";

}

cout << "Taken pieces: " << takenPiecesList() << "\n";

}

/*

* Checks if the given move is valid.

*

* The check is based on the originating coordinates and the targeted

* coordinates.

*

*/

int validMove(int ox, int oy, int dx, int dy){

int source = board[oy][ox];

int target = board[dy][dx];

// cout << "Validating move for " << displayPiece(source) << "@" << ox << "," << oy

// << " to " << target << "@" << dx << "," << dy << "\n";

switch(abs(source)){

//Pawn

case ۱: case -۱:

if(dx==ox && abs(dy-oy)==1 && target==0) return 1;

if(abs(dx-ox)==۱ && abs(dy-oy)==1 && target!= 0) return 1;

if(current_player == ۱ && oy==1 && abs(oy-dy)==2 && target == 0) return 1;

if(current_player == ۲ && oy==6 && abs(oy-dy)==2 && target == 0) return 1;

// TODO: Check for en-passant

break;

// Rock

case ۲:

if(dx==ox){ // Moving vertically

if(dy>oy){ // Downards

for(size_t row = (unsigned)(oy+۱); row < (unsigned)dy; ++row){

if(board[row][dx] != ۰) return ۰;

}

} else { // Upwards

for(size_t row = (unsigned)dy; row < (unsigned)(oy-۱); ++row){

if(board[row][dx] != ۰) return ۰;

}

return ۱;

}

if(dy==oy){ // Moving horizontally

if(dx>ox){ // Rightwards

for(size_t column = (unsigned)(ox+۱); column < (unsigned)dy; ++column){

if(board[dy][column] != ۰) return ۰;

}

if(dx<ox){ // Leftwards

for(size_t column = (unsigned)dx; column < (unsigned)(ox-۱); ++column){

if(board[dy][column] != ۰) return ۰;

}

return ۱;

}

return ۰;

break;

// Knight

case ۳:

if((abs(dy-oy)==۲ && abs(dx-ox)==1) || (abs(dx-ox)==2 && abs(dy-oy)==1)){

return 1;

}

return ۰;

break;

// Bishop

case ۴:

if(abs(dy-oy) == abs(dx-ox)){ // Moving diagonally

if(dy>oy){ // South

int column = min(dx, ox)+۱;

for(size_t row = oy+۱; row < (unsigned)dy; ++row){

if(board[row][column] != ۰) return ۰;

column ++;

}

return ۱;

}

if(dy<oy && dx>ox){ // North

int column = min(dx, ox)+1;

for(size_t row = oy+۱; row < (unsigned)dy; ++row){

if(board[row][column] != ۰) return ۰;

column ++;

}

return ۱;

}

return ۰;

break;

// Queen

case ۵:

if(abs(dy-oy) == abs(dx-ox)){ // Moving diagonally

if(dy>oy){ // South

int column = min(dx, ox)+۱;

for(size_t row = oy+۱; row < (unsigned)dy; ++row){

if(board[row][column] != ۰) return ۰;

column ++;

}

return ۱;

}

if(dy<oy && dx>ox){ // North

int column = min(dx, ox)+1;

for(size_t row = oy+۱; row < (unsigned)dy; ++row){

if(board[row][column] != ۰) return ۰;

column ++;

}

return ۱;

}

if(dy==oy || dx==ox){ // Moving straight

if(dx==ox){ // Moving vertically

if(dy>oy){ // Downards

for(size_t row = (unsigned)(oy+۱); row < (unsigned)dy; ++row){

if(board[row][dx] != ۰) return ۰;

}

} else { // Upwards

for(size_t row = (unsigned)dy; row < (unsigned)(oy-۱); ++row){

if(board[row][dx] != ۰) return ۰;

}

return ۱;

}

if(dy==oy){ // Moving horizontally

if(dx>ox){ // Rightwards

for(size_t column = (unsigned)(ox+۱); column < (unsigned)dy; ++column){

if(board[dy][column] != ۰) return ۰;

}

if(dx<ox){ // Leftwards

for(size_t column = (unsigned)dx; column < (unsigned)(ox-۱); ++column){

if(board[dy][column] != ۰) return ۰;

}

return ۱;

}

return ۰;

break;

// King

case ۶:

if(abs(dy-oy)<=۱ && abs(dx-ox)<=1) return 1;

// TODO: Check for castling

return ۰;

break;

}

return ۰;

}

/*

* Logs the given +piece+ into the +taken_pieces+ list.

*

*/

void logTakenPiece(int piece){

string piece_str = displayPiece(piece, ۱);

if(piece_str.length()>۰){

if(taken_pieces.length()>۰) taken_pieces=taken_pieces+",";

taken_pieces=taken_pieces+displayPiece(piece);

}

/*

* Displays the help message

*

* TODO: Move the help message into the help.txt file.

*

*/

void displayHelp(){

cout << "\n\n";

cout << "When asked for a move, please enter a move in the following fasion: from>to. This means, that if you want to move from a1 to a2 then you should write a1>a2.\n";

cout << "If you get the warning: Illegal move it means that you entered a move that's either impossible with the selected piece or you't trying to take one of your own pieces or you'r trying to move out of the board.\n";

cout << "Typing reset will reset the game back to starting position. Typing display will redraw the board. Typing exit or quit will exit the game.\n";

}

/*

* Gets a letter (a..h) from a number (1..8)

*

*/

string getLetter(int column){

switch(column){

case ۰: return "a"; break;

case ۱: return "b"; break;

case ۲: return "c"; break;

case ۳: return "d"; break;

case ۴: return "e"; break;

case ۵: return "f"; break;

case ۶: return "g"; break;

}

return "n/a";

}

/*

* Converts a given letter (a..h) into a corresponding number (1..8)

*

*/

int getNumber(string letter){

if(letter == "a") return ۰;

if(letter == "b") return ۱;

if(letter == "c") return ۲;

if(letter == "d") return ۳;

if(letter == "e") return ۴;

if(letter == "f") return ۵;

if(letter == "g") return ۶;

if(letter == "h") return ۷;

return ۰;

}

/*

* Catches the users inputted move

*

* This also does some validation of the move..

* DISCUSS: Should all validation be moved somewhere else?

*

*/

int getMove(){

cout << "Turn " << turn_counter << ". " << currentPlayerColor() <<", select a move:";

string move = "";

cin >> move;

// Checks if the move is a command

if(move == "help"){ // Display help

displayHelp();

displayBoard();

return ۰;

}

if(move == "reset"){ // Reset the game

reset(); displayBoard(); return ۰;

}

if(move == "display"){ // Displays the board

displayBoard(); return ۰;

}

if(move == "exit" || move == "quit") exit(۱);

// Splits the move into orgination and destrination and those

// into x and y parts

// TODO: Add validation of the y-coordinate of both the

// destination and the origination.

int ox = ۰; int oy = ۰; int dx = ۰; int dy = ۰;

string ox_part = move.substr(۰, move.find(">")).substr(۰, ۱);

string oy_part = move.substr(۰, move.find(">")).substr(۱, ۱);

string dx_part = move.substr(move.find(">")+۱, move.length()).substr(۰, ۱);

string dy_part = move.substr(move.find(">")+۱, move.length()).substr(۱, ۱);

ox = getNumber(ox_part);

oy = atoi(oy_part.c_str())-۱;

dx = getNumber(dx_part);

dy = atoi(dy_part.c_str())-۱;

// Gets the piece in question and moves it

int source = board[oy][ox];

int target = board[dy][dx];

if((current_player == ۱ && (source <= 0 || target > 0)) || (current_player == 2 && (source >= 0 || target < 0)) || !validMove(ox, oy, dx, dy)){

cout << "Illegal move\n"; return ۰;

}

// Moves the piece

board[oy][ox] = ۰;

board[dy][dx] = source;

logTakenPiece(target);

// Checks for win condition

// Changes the +status+ for the game to the +current_player+

if(abs(target) == king){

status = current_player;

return ۰;

}

// Increments the +turn_counter+

turn_counter ++;

// Changes the turn

current_player = oppositePlayer();

// Redraws the board

displayBoard();

return ۰;

}

/*

* Displays the about.txt file content

*

* TODO: Add the about.txt file

*

*/

void displayGameInformation(){

cout << "This is a game os chess to be played between to humans. To get help with movements and such, type 'help'.\n";

}

/*

* Initializes the program and contains the main loop that keeps the game

* alive.

*

*/

int main(){

displayGameInformation();

reset();

displayBoard();

while(exit_game == ۰){

while(status == ۰){

getMove();

}

// Displays win condition

cout << currentPlayerColor() << " wins! Start a new game? [y/n]:";

string new_game = "y";

cin >> new_game;

if(new_game == "y"){

reset();

displayBoard();

} else {

exit_game = ۱;

}

cout << "Thank you for playing.\n";

return ۰;

}

موفق باشید.

عضویت در سایت

ورود

فراموشی رمز عبور

ورود

عضویت در سایت

شطرنچ

شطرنچ

درباره zzکاربر تازه

پرسش های مشابه

کمک در نوشتن این برنامه به زبان++c

سوال تمرین برنامه نویسی

mfcدر ++ visual c

نوع زبان و محیط نوشتن

پاسخ ( 1 )

ارسال یک پاسخ

سامانه آموزشی و خدماتی بپرسم

اولین وب سایت آموزشی و پرسش و پاسخ در ایران