import of pgn files with examples

.editorconfig

@@ -7,4 +7,8 @@ indent_style = space
 trim_trailing_whitespace = true
 
 [*.{cc,cpp,hpp,h}]
-insert_final_newline = true
+insert_final_newline = true
+
+[makefile]
+indent_size = 4
+indent_style = tab

.gitignore

@@ -1,3 +1,4 @@
 .vscode/
 *.exe
-*.txt
+*.txt
+chess

ChessPieces/ChessPiece.cpp

@@ -127,6 +127,54 @@ ChessPiecePosition ChessPiece::GetPosition() {
   }
 }
 
+/**
+ * Gets all chess piece positions of the chess piece which are still protective for the king.
+ * Any position between the attacker chess piece and the current chess piece is protective for the king.
+ * The position is also protective for the king if the chess piece can beat the attacker chess piece.
+ * @param chessboard A pointer to the chessboard.
+ * @param positions A set of positions the chess piece can move next (also positions are not protective).
+ * @return A set of chess piece positions which are still protective for the king.
+ */
+std::set<ChessPiecePosition> ChessPiece::GetProtectivePositions(Chessboard* chessboard, std::set<ChessPiecePosition> positions) {
+  ChessPiece* chessPieceKing = chessboard->GetChessPieceKing(this->GetColor());
+  std::set<ChessPiecePosition> protectivePositions;
+
+  for (ChessPiece* chessPiece : chessboard->GetChessPieces()) {
+    if (chessPiece->GetColor() != this->GetColor()) {
+      std::set<ChessPiecePosition> positionsStay = chessPiece->GetNextPositions(chessboard, {});
+      std::set<ChessPiecePosition> positionsMove = chessPiece->GetNextPositions(chessboard, {this->GetPosition()});
+
+      if (positionsStay.count(chessPieceKing->GetPosition()) == 0 && positionsMove.count(chessPieceKing->GetPosition()) == 1)  {
+
+        // the position is protective if the current chess piece can beat the attacker chess piece.
+        if (positions.count(chessPiece->GetPosition()) == 1) {
+          protectivePositions.insert(chessPiece->GetPosition());
+        }
+
+        // every position between the current chess piece and the attacker chess piece is also protective.
+        std::string step = ChessPiecePosition::GetStep(chessPiece->GetPosition(), chessPieceKing->GetPosition());
+
+        if (step.empty()) {
+          continue;
+        }
+
+        ChessPiecePosition currentPosition = chessPiece->GetPosition();
+        ChessPiecePosition* nextPosition = &currentPosition;
+
+        while (nextPosition = nextPosition->NextFromString(step)) {
+          if (nextPosition->ToString() == this->GetPosition().ToString()) {
+            break;
+          } else if (positions.count(*nextPosition) == 1) {
+            protectivePositions.insert(*nextPosition);
+          }
+        }
+      }
+    }
+  }
+
+  return protectivePositions;
+}
+
 /**
  * Gets a set of all positions along the rank.
  * @param chessboard A pointer to the chessboard.
@@ -300,7 +348,7 @@ void ChessPiece::SetPosition(ChessPiecePosition position) {
  */
 void ChessPiece::UpdateNextPositions(Chessboard* chessboard) {
   if (this->IsProtective(chessboard)) {
-    this->SetNextPositions({});
+    this->SetNextPositions(this->GetProtectivePositions(chessboard, this->GetNextPositions(chessboard)));
   } else {
     this->SetNextPositions(this->GetNextPositions(chessboard));
   }

ChessPieces/ChessPiece.hpp

@@ -14,6 +14,8 @@ class ChessPiece {
     ChessPieceColor _color;
     std::vector<ChessPiecePosition> _positions;
     std::set<ChessPiecePosition> _positions_next;
+    std::set<ChessPiecePosition> GetProtectivePositions(Chessboard* chessboard, std::set<ChessPiecePosition> positions);
+    bool IsProtective(Chessboard* chessboard);
 
   protected:
     char _char = '\0';
@@ -46,7 +48,6 @@ class ChessPiece {
     bool IsKing();
     bool IsKnight();
     bool IsPawn();
-    bool IsProtective(Chessboard* chessboard);
     bool IsQueen();
     bool IsRook();
     void SetPosition(ChessPiecePosition position);

ChessPieces/ChessPieceMove.cpp

@@ -0,0 +1,171 @@
+#include "../ChessPieces/ChessPieceMove.hpp"
+
+/**
+ * Creates a new move of a chess piece that uses the short algebraic notation.
+ * @param move The move that uses the short algebraic notation.
+ */
+ChessPieceMove::ChessPieceMove(std::string move) {
+  move = this->Normalize(move);
+
+  if (this->IsValidShortNotation(move)) {
+    this->_move = move;
+    this->ParseShortNotation();
+  } else {
+    throw std::invalid_argument("invalid move notation");
+  }
+}
+
+/**
+ * Status whether the move is a valid move that uses the short algebraic notation.
+ * @return Status whether the move is a valid move that uses the short algebraic notation.
+ */
+bool ChessPieceMove::IsValidShortNotation(std::string move) {
+  if (move.empty()) {
+    return std::regex_match(this->_move, this->_notation);
+  } else {
+    return std::regex_match(move, this->_notation);
+  }
+}
+
+/**
+ * Normalizes the move which, if valid, can then be parsed.
+ * @param move The move to be normalized.
+ * @return The normalized move which, if valid, can then be parsed.
+ */
+std::string ChessPieceMove::Normalize(std::string move) {
+  std::replace(move.begin(), move.end(), 'O', '0'); // castling: portable game notation to algebraic notation
+  std::replace(move.begin(), move.end(), 'S', 'N'); // german notation to english notation (knight)
+  std::replace(move.begin(), move.end(), 'L', 'B'); // german notation to english notation (bishop)
+  std::replace(move.begin(), move.end(), 'T', 'R'); // german notation to english notation (queen)
+  return move;
+}
+
+/**
+ * Parses a move that uses the short algebraic notation.
+ */
+void ChessPieceMove::ParseShortNotation() {
+  std::smatch parts;
+  std::regex_search(this->_move, parts, this->_notation);
+  this->_chessPiece = parts[1].str();
+  this->_fromPositionFile = parts[2].str();
+  this->_fromPositionRank = parts[3].str();
+  this->_capture = parts[4].str();
+  this->_toPositionFile = parts[5].str();
+  this->_toPositionRank = parts[6].str();
+  this->_promotion = parts[7].str();
+  this->_castling = parts[8].str();
+  this->_draw = parts[9].str();
+  this->_additional = parts[10].str();
+}
+
+/**
+ * Gets the chess piece char of the move.
+ * @return The chess piece char of the move.
+ */
+char ChessPieceMove::GetChessPieceChar() {
+  return this->_chessPiece.empty() ? 'P' : this->_chessPiece[0];
+}
+
+/**
+ * Gets the file part of the source position.
+ * @return The file part of the source position.
+ */
+char ChessPieceMove::GetFromPositionFile() {
+  return this->_fromPositionFile.empty() ? '\0' : this->_fromPositionFile[0];
+}
+
+/**
+ * Gets the rank part of the source position.
+ * @return The rank part of the source position.
+ */
+int ChessPieceMove::GetFromPositionRank() {
+  return this->_fromPositionRank.empty() ? 0 : stoi(this->_fromPositionRank);
+}
+
+/**
+ * Gets the chess piece character of the promotion.
+ * @return The chess piece character of the promotion.
+ */
+char ChessPieceMove::GetPromotionChessPieceChar() {
+  return this->_promotion.empty() ? '\0' : this->_promotion[this->_promotion.length() - 1];
+}
+
+/**
+ * Gets the file part of the target position.
+ * @return The file part of the target position.
+ */
+char ChessPieceMove::GetToPositionFile() {
+  return this->_toPositionFile.empty() ? '\0' : this->_toPositionFile[0];
+}
+
+/**
+ * Gets the rank part of the target position.
+ * @return The rank part of the target position.
+ */
+int ChessPieceMove::GetToPositionRank() {
+  return this->_toPositionRank.empty() ? 0 : stoi(this->_toPositionRank);
+}
+
+/**
+ * Status whether the move is a move with capture.
+ * @return Status whether the move is a move with capture.
+ */
+bool ChessPieceMove::IsCapture() {
+  return this->_capture == "x" ? true : false;
+}
+
+/**
+ * Status whether the move results in a check.
+ * @return Status whether the move results in a check.
+ */
+bool ChessPieceMove::IsCheck() {
+  return this->_additional == "+";
+}
+
+/**
+ * Status whether the move results in a checkmate.
+ * @return Status whether the move results in a checkmate.
+ */
+bool ChessPieceMove::IsCheckmate() {
+  return this->_additional == "++" || this->_additional == "#";
+}
+
+/**
+ * Status whether the move is a offer for a draw.
+ * @return Status whether the move is a offer for a draw.
+ */
+bool ChessPieceMove::IsDrawOffer() {
+  return this->_draw == "(=)";
+}
+
+/**
+ * Status whether the move is an "en passant" by pawn.
+ * @return Status whether the move is an "en passant" by pawn.
+ */
+bool ChessPieceMove::IsEnPassant() {
+  return this->_additional == "e.p.";
+}
+
+/**
+ * Status whether the move is the long castling (castling queenside).
+ * @return Status whether the move is the long castling (castling queenside).
+ */
+bool ChessPieceMove::IsLongCastling() {
+  return this->_castling == "0-0-0";
+}
+
+/**
+ * Status whether the move is the short castling (castling kingside).
+ * @return Status whether the move is the short castling (castling kingside).
+ */
+bool ChessPieceMove::IsShortCastling() {
+  return this->_castling == "0-0";
+}
+
+/**
+ * Gets the move of the chess piece as string value.
+ * @return The move of the chess piece as string value.
+ */
+std::string ChessPieceMove::ToString() {
+  return (this->IsValidShortNotation()) ? this->_move : "";
+}

ChessPieces/ChessPieceMove.hpp

@@ -0,0 +1,42 @@
+#ifndef ChessPieceMove_H
+#define ChessPieceMove_H
+
+#include <regex>
+
+class ChessPieceMove {
+  private:
+    std::string _chessPiece;
+    std::string _fromPositionFile;
+    std::string _fromPositionRank;
+    std::string _capture;
+    std::string _toPositionFile;
+    std::string _toPositionRank;
+    std::string _promotion;
+    std::string _castling;
+    std::string _draw;
+    std::string _additional;
+    std::string _move;
+    const std::regex _notation = std::regex("^(?:([RNBQKP]?)([a-h]?)([1-8]?)(x?)([a-h])([1-8])((?:[=])?[QRBN])?|(0-0(?:-0)?)|(\\(=\\)))([+#!?]| e.p.)*$");
+    std::string Normalize(std::string move);
+    void ParseShortNotation();
+
+  public:
+    ChessPieceMove(std::string move);
+    bool IsValidShortNotation(std::string move = "");
+    char GetChessPieceChar();
+    char GetFromPositionFile();
+    int GetFromPositionRank();
+    bool IsCapture();
+    char GetToPositionFile();
+    int GetToPositionRank();
+    char GetPromotionChessPieceChar();
+    bool IsShortCastling();
+    bool IsLongCastling();
+    bool IsDrawOffer();
+    bool IsCheck();
+    bool IsCheckmate();
+    bool IsEnPassant();
+    std::string ToString();
+};
+
+#endif

ChessPieces/ChessPiecePosition.cpp

@@ -56,18 +56,18 @@ std::string ChessPiecePosition::GetDifference(ChessPiecePosition fromPosition, C
   } else {
     std::string difference;
 
-    if (toPosition.GetFile() < fromPosition.GetFile()) {
-      difference.append(std::string(1, ChessPiecePosition::_MOVE_LEFT) + std::to_string(fromPosition.GetFile() - toPosition.GetFile()));
-    } else if (toPosition.GetFile() > fromPosition.GetFile()) {
-      difference.append(std::string(1, ChessPiecePosition::_MOVE_RIGHT) + std::to_string(toPosition.GetFile() - fromPosition.GetFile()));
-    }
-
     if (toPosition.GetRank() < fromPosition.GetRank()) {
       difference.append(std::string(1, ChessPiecePosition::_MOVE_BOTTOM) + std::to_string(fromPosition.GetRank() - toPosition.GetRank()));
     } else if (toPosition.GetRank() > fromPosition.GetRank()) {
       difference.append(std::string(1, ChessPiecePosition::_MOVE_TOP) + std::to_string(toPosition.GetRank() - fromPosition.GetRank()));
     }
 
+    if (toPosition.GetFile() < fromPosition.GetFile()) {
+      difference.append(std::string(1, ChessPiecePosition::_MOVE_LEFT) + std::to_string(fromPosition.GetFile() - toPosition.GetFile()));
+    } else if (toPosition.GetFile() > fromPosition.GetFile()) {
+      difference.append(std::string(1, ChessPiecePosition::_MOVE_RIGHT) + std::to_string(toPosition.GetFile() - fromPosition.GetFile()));
+    }
+
     return difference;
   }
 }

ChessPieces/King.cpp

@@ -34,7 +34,33 @@ std::set<ChessPiecePosition> King::GetNextPositions(Chessboard* chessboard, std:
       ChessPieceColor opponentColor = (this->GetColor() == ChessPieceColor::Black) ? ChessPieceColor::White : ChessPieceColor::Black;
 
       if (chessboard->IsPositionUnderAttack(*nextPosition, opponentColor) == false) {
-        positions.insert(*nextPosition);
+        bool isUnderAttackAfterMove = false;
+
+        // Positions are ignored which are still under attack after the king has moved.
+        // There are fields under attack which are in the shadow of the king.
+        for (ChessPiece* chessPiece : chessboard->GetChessPieces()) {
+          if (chessPiece && chessPiece->GetColor() != this->GetColor()) {
+            if (chessPiece->GetNextPositions().count(this->GetPosition()) == 1) {
+              if (chessPiece->GetNextPositions(chessboard, {this->GetPosition(), *nextPosition}).count(*nextPosition) == 1) {
+                isUnderAttackAfterMove = true;
+                break;
+              }
+            } else if (chessPiece->IsKing()) {
+              for (std::string nextMove : {"T1", "T1L1", "T1R1", "R1", "L1", "B1", "B1L1", "B1R1"}) {
+                ChessPiecePosition* nextPositionKing = chessPiece->GetPosition().NextFromString(nextMove);
+
+                if (nextPositionKing && *nextPosition == *nextPositionKing) {
+                  isUnderAttackAfterMove = true;
+                  break;
+                }
+              }
+            }
+          }
+        }
+
+        if (isUnderAttackAfterMove == false) {
+          positions.insert(*nextPosition);
+        }
       }
     }
   }

ChessPieces/Pawn.cpp

@@ -21,148 +21,70 @@ std::set<ChessPiecePosition> Pawn::GetNextPositions(Chessboard* chessboard, std:
   std::set<ChessPiecePosition> positions;
   ChessPiecePosition currentPosition = this->GetPosition();
   ChessPiecePosition* nextPosition = &currentPosition;
+  std::vector<std::string> nextDiagonalPositions;
+  std::string moveDifferenceOpponent;
 
-  if (this->GetColor() == ChessPieceColor::Black) {
+  if (this->GetColor() == ChessPieceColor::White) {
+    nextDiagonalPositions = {"T1L1", "T1R1"};
+    moveDifferenceOpponent = "B2";
+  } else {
+    nextDiagonalPositions = {"B1L1", "B1R1"};
+    moveDifferenceOpponent = "T2";
+  }
 
-    // 3.7.1. The pawn may move forward to the square immediately in front of it on the same file, provided that this square is unoccupied.
+  std::string stepVertical = nextDiagonalPositions[0].substr(0, 2);
-    // 3.7.2. On its first move the pawn may move as in 3.7.1 or alternatively it may advance two squares along the same file, provided that both squares are unoccupied.
-    for (int move = 1; move <= 2; move++) {
-      nextPosition = nextPosition->NextBottom();
 
-      if (nextPosition) {
+  // 3.7.1. The pawn may move forward to the square immediately in front of it on the same file, provided that this square is unoccupied.
-        if (chessboard->IsEmptyField(nextPosition) == false) {
+  // 3.7.2. On its first move the pawn may move as in 3.7.1 or alternatively it may advance two squares along the same file, provided that both squares are unoccupied.
-          break;
+  for (int move = 1; move <= 2; move++) {
-        }
+    if (nextPosition = nextPosition->NextFromString(stepVertical)) {
-
+      if (chessboard->IsEmptyField(nextPosition) == false) {
-        if (move == 1) {
-          positions.insert(*nextPosition);
-        } else if (move == 2 && this->IsFirstMove()) {
-          positions.insert(*nextPosition);
-        }
-      } else {
         break;
       }
-    }
 
-    // 3.7.3. the pawn may move to a square occupied by an opponent's piece diagonally in front of it on an adjacent file, capturing that piece.
+      if (move == 1 || (move == 2 && this->IsFirstMove())) {
-    for (std::string move : {"B1L1", "B1R1"}) {
+        positions.insert(*nextPosition);
+      }
+    } else {
+      break;
+    }
+  }
+
+  // 3.7.3. the pawn may move to a square occupied by an opponent's piece diagonally in front of it on an adjacent file, capturing that piece.
+  for (std::string moveDiagonal : nextDiagonalPositions) {
+    nextPosition = &currentPosition;
+    nextPosition = nextPosition->NextFromString(moveDiagonal);
+
+    if (nextPosition && chessboard->IsEmptyField(nextPosition) == false) {
+      ChessPiece* chessPiece = chessboard->GetChessPiece(nextPosition);
+
+      if (chessPiece->GetColor() != this->GetColor()) {
+        positions.insert(*nextPosition);
+      }
+    }
+  }
+
+  // 3.7.3.1. A pawn occupying a square on the same rank as and on an adjacent file to an opponent's pawn which has just advanced two squares
+  // in one move from its original square may capture this opponent's pawn as though the latter had been moved only one square.
+  // 3.7.3.2. This capture is only legal on the move following this advance and is called an "en passant" capture.
+  if (chessboard->HasMoves()) {
+    std::pair<ChessPiecePosition, ChessPiecePosition> lastMovePositions = chessboard->GetLastMovePositions();
+    std::string moveDifference = ChessPiecePosition::GetDifference(lastMovePositions.first, lastMovePositions.second);
+
+    for (std::string nextDiagonalPosition : nextDiagonalPositions) {
       nextPosition = &currentPosition;
-      nextPosition = nextPosition->NextFromString(move);
+      std::string stepDiagonal = nextDiagonalPosition.substr(2, 2);
+      nextPosition = nextPosition->NextFromString(stepDiagonal);
 
       if (nextPosition && chessboard->IsEmptyField(nextPosition) == false) {
         ChessPiece* chessPiece = chessboard->GetChessPiece(nextPosition);
 
-        if (chessPiece->GetColor() != this->GetColor()) {
+        if (chessPiece->IsPawn() && chessPiece->GetColor() != this->GetColor()) {
-          positions.insert(*nextPosition);
+          if (chessPiece->GetNumberOfMoves() == 1 && moveDifference == moveDifferenceOpponent && chessPiece->GetPosition() == lastMovePositions.second) {
-        }
+            ChessPiecePosition* diagonalPosition = currentPosition.NextFromString(nextDiagonalPosition);
-      }
-    }
 
-    // 3.7.3.1. A pawn occupying a square on the same rank as and on an adjacent file to an opponent's pawn which has just advanced two squares
+            if (diagonalPosition && chessboard->IsEmptyField(diagonalPosition)) {
-    // in one move from its original square may capture this opponent's pawn as though the latter had been moved only one square.
+              positions.insert(*diagonalPosition);
-    // 3.7.3.2. This capture is only legal on the move following this advance and is called an "en passant" capture.
-    if (chessboard->GetCountMoves() > 0) {
-      std::pair<ChessPiecePosition, ChessPiecePosition> lastMove = chessboard->GetLastMove();
-      std::string moveDifference = ChessPiecePosition::GetDifference(lastMove.first, lastMove.second);
-      ChessPiecePosition* leftPosition = currentPosition.NextLeft();
-      ChessPiecePosition* rightPosition = currentPosition.NextRight();
-
-      if (leftPosition && chessboard->IsEmptyField(leftPosition) == false) {
-        ChessPiece* chessPiece = chessboard->GetChessPiece(leftPosition);
-
-        if (chessPiece->GetColor() != this->GetColor() && chessPiece->IsPawn()) {
-          if (chessPiece->GetNumberOfMoves() == 1 && moveDifference == "T2" && chessPiece->GetPosition() == lastMove.second) {
-            ChessPiecePosition* bottomLeftPosition = currentPosition.NextFromString("B1L1");
-
-            if (bottomLeftPosition && chessboard->IsEmptyField(bottomLeftPosition)) {
-              positions.insert(*bottomLeftPosition);
-            }
-          }
-        }
-      }
-
-      if (rightPosition && chessboard->IsEmptyField(rightPosition) == false) {
-        ChessPiece* chessPiece = chessboard->GetChessPiece(rightPosition);
-
-        if (chessPiece->GetColor() != this->GetColor() && chessPiece->IsPawn()) {
-          if (chessPiece->GetNumberOfMoves() == 1 && moveDifference == "T2" && chessPiece->GetPosition() == lastMove.second) {
-            ChessPiecePosition* bottomRightPosition = currentPosition.NextFromString("B1R1");
-
-            if (bottomRightPosition && chessboard->IsEmptyField(bottomRightPosition)) {
-              positions.insert(*bottomRightPosition);
-            }
-          }
-        }
-      }
-    }
-  } else if (this->GetColor() == ChessPieceColor::White) {
-
-    // 3.7.1. The pawn may move forward to the square immediately in front of it on the same file, provided that this square is unoccupied.
-    // 3.7.2. On its first move the pawn may move as in 3.7.1 or alternatively it may advance two squares along the same file, provided that both squares are unoccupied.
-    for (int move = 1; move <= 2; move++) {
-      nextPosition = nextPosition->NextTop();
-
-      if (nextPosition) {
-        if (chessboard->IsEmptyField(nextPosition) == false) {
-          break;
-        }
-
-        if (move == 1) {
-          positions.insert(*nextPosition);
-        } else if (move == 2 && this->IsFirstMove()) {
-          positions.insert(*nextPosition);
-        }
-      } else {
-        break;
-      }
-    }
-
-    // 3.7.3. the pawn may move to a square occupied by an opponent's piece diagonally in front of it on an adjacent file, capturing that piece.
-    for (std::string move : {"T1L1", "T1R1"}) {
-      nextPosition = &currentPosition;
-      nextPosition = nextPosition->NextFromString(move);
-
-      if (nextPosition && chessboard->IsEmptyField(nextPosition) == false) {
-        ChessPiece* chessPiece = chessboard->GetChessPiece(nextPosition);
-
-        if (chessPiece->GetColor() != this->GetColor()) {
-          positions.insert(*nextPosition);
-        }
-      }
-    }
-
-    // 3.7.3.1. A pawn occupying a square on the same rank as and on an adjacent file to an opponent's pawn which has just advanced two squares
-    // in one move from its original square may capture this opponent's pawn as though the latter had been moved only one square.
-    // 3.7.3.2. This capture is only legal on the move following this advance and is called an "en passant" capture.
-    if (chessboard->GetCountMoves() > 0) {
-      std::pair<ChessPiecePosition, ChessPiecePosition> lastMove = chessboard->GetLastMove();
-      std::string moveDifference = ChessPiecePosition::GetDifference(lastMove.first, lastMove.second);
-      ChessPiecePosition* leftPosition = currentPosition.NextLeft();
-      ChessPiecePosition* rightPosition = currentPosition.NextRight();
-
-      if (leftPosition && chessboard->IsEmptyField(leftPosition) == false) {
-        ChessPiece* chessPiece = chessboard->GetChessPiece(leftPosition);
-
-        if (chessPiece->GetColor() != this->GetColor() && chessPiece->IsPawn()) {
-          if (chessPiece->GetNumberOfMoves() == 1 && moveDifference == "B2" && chessPiece->GetPosition() == lastMove.second) {
-            ChessPiecePosition* topLeftPosition = currentPosition.NextFromString("T1L1");
-
-            if (topLeftPosition && chessboard->IsEmptyField(topLeftPosition)) {
-              positions.insert(*topLeftPosition);
-            }
-          }
-        }
-      }
-
-      if (rightPosition && chessboard->IsEmptyField(rightPosition) == false) {
-        ChessPiece* chessPiece = chessboard->GetChessPiece(rightPosition);
-
-        if (chessPiece->GetColor() != this->GetColor() && chessPiece->IsPawn()) {
-          if (chessPiece->GetNumberOfMoves() == 1 && moveDifference == "B2" && chessPiece->GetPosition() == lastMove.second) {
-            ChessPiecePosition* topRightPosition = currentPosition.NextFromString("T1R1");
-
-            if (topRightPosition && chessboard->IsEmptyField(topRightPosition)) {
-              positions.insert(*topRightPosition);
             }
           }
         }

Chessboard/Chessboard.cpp

@@ -1,10 +1,308 @@
 #include "../Chessboard/Chessboard.hpp"
+#include "../ChessPieces/Rook.hpp"
+#include "../ChessPieces/Queen.hpp"
+#include "../ChessPieces/Bishop.hpp"
+#include "../ChessPieces/Knight.hpp"
 #include "../ChessPieces/ChessPiece.hpp"
 
+/**
+ * Gets the current player.
+ * @return A pointer to the current player.
+ */
+Player* Chessboard::GetCurrentPlayer() {
+  return this->currentPlayer;
+}
+
+/**
+ * Gets the history of all moves.
+ * @return The history of all moves.
+ */
+std::vector<ChessPieceMove> Chessboard::GetHistoryMoves() {
+  return this->_historyMoves;
+}
+
+/**
+ * Gets the history of all positions.
+ * @return The history of all positions.
+ */
+std::vector<std::pair<ChessPiecePosition, ChessPiecePosition>> Chessboard::GetHistoryPositions() {
+  return this->_historyPositions;
+}
+
+/**
+ * Gets the opponent player.
+ * @return A pointer to the opponent player.
+ */
+Player* Chessboard::GetOpponentPlayer() {
+  if (this->GetCurrentPlayer()->GetColor() == ChessPieceColor::Black) {
+    return this->GetPlayer(ChessPieceColor::White);
+  } else {
+    return this->GetPlayer(ChessPieceColor::Black);
+  }
+}
+
+/**
+ * Gets a player by the specified color.
+ * @return Player* A pointer to the player with the specified color.
+ */
+Player* Chessboard::GetPlayer(ChessPieceColor color) {
+  if (color == ChessPieceColor::Black) {
+    return std::get<ChessPieceColor::Black>(this->players);
+  } else {
+    return std::get<ChessPieceColor::White>(this->players);
+  }
+}
+
+/**
+ * Status whether moves have already been made.
+ * @return Status whether moves have already been made.
+ */
+bool Chessboard::HasMoves() {
+  return this->_historyMoves.size() > 0;
+}
+
+/**
+ * Load the chessboard from a PGN file.
+ * @param filePath The file path of the PGN file to load.
+ * @return The status whether the PGN file was loaded successfully.
+ */
+bool Chessboard::ImportFilePGN(std::string filePath) {
+  std::ifstream pgnFile(filePath);
+  std::regex rgxMetaInfo = std::regex("^[\\[]([A-Za-z]+) [\"](.*)[\"][\\]]$");
+  std::regex rgxMoveInfo = std::regex("(?:([RNBQKP]?)([a-h]?)([1-8]?)(x?)([a-h])([1-8])((?:[=])?[QRBN])?|(O-O(?:-O)?)|(\\(=\\)))([+#!?]| e.p.)*");
+
+  if (pgnFile.is_open()) {
+    Player* playerWhite;
+    Player* playerBlack;
+    int expectedNumberOfMoves = 0;
+    std::vector<std::string> moves;
+
+    for(std::string line; getline(pgnFile, line);) {
+      std::smatch parts;
+
+      if (std::regex_search(line, parts, rgxMetaInfo)) {
+        std::string metaName = parts[1].str();
+        std::string metaValue = parts[2].str();
+
+        if (metaName == "White") {
+          playerWhite = new Player(metaValue);
+          playerWhite->SetColor(ChessPieceColor::White);
+        } else if (metaName == "Black") {
+          playerBlack = new Player(metaValue);
+          playerBlack->SetColor(ChessPieceColor::Black);
+        } else if (metaName == "PlyCount") {
+          expectedNumberOfMoves = std::stoi(metaValue);
+        }
+      } else {
+        for (std::sregex_iterator rgxIterator = std::sregex_iterator(line.begin(), line.end(), rgxMoveInfo); rgxIterator != std::sregex_iterator(); ++rgxIterator) {
+          parts = *rgxIterator;
+          moves.push_back(parts[0].str());
+        }
+      }
+    }
+
+    pgnFile.close();
+
+    if (expectedNumberOfMoves != moves.size()) {
+      return false;
+    }
+
+    this->players = {playerBlack, playerWhite};
+
+    for (std::string move : moves) {
+      this->MoveChessPiece(move);
+    }
+
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Status whether the king of the current player is in checkmate.
+ * @return Status whether the king of the current player is in checkmate.
+ */
+bool Chessboard::IsCheckmate() {
+  int numberOfAttackers = 0;
+
+  if (this->IsInCheck() == false) {
+    return false;
+  }
+
+  ChessPiece* chessPieceKing = this->GetChessPieceKing(this->GetCurrentPlayer()->GetColor());
+
+  if (chessPieceKing == nullptr) {
+    throw std::domain_error("king is missing");
+  }
+
+  // it is not checkmate if the king can move to another position.
+  if (chessPieceKing->GetNextPositions().size() > 0) {
+    return false;
+  }
+
+  for (ChessPiece* chessPieceOpponent : this->GetChessPieces()) {
+    if (chessPieceOpponent->GetColor() == this->GetOpponentPlayer()->GetColor()) {
+      if (chessPieceOpponent->GetNextPositions().count(chessPieceKing->GetPosition()) == 1) {
+        bool isDefensibleAttack = false;
+        numberOfAttackers++;
+
+        // the attacker can be removed directly by another chess piece.
+        for (ChessPiece* chessPieceCurrent : this->GetChessPieces()) {
+          if (chessPieceCurrent->GetColor() == this->GetCurrentPlayer()->GetColor()) {
+            if (chessPieceCurrent->GetNextPositions().count(chessPieceOpponent->GetPosition()) == 1) {
+              isDefensibleAttack = true;
+              break;
+            }
+          }
+        }
+
+        // the attacker is defensible.
+        if (isDefensibleAttack == true) {
+          std::cout << isDefensibleAttack << std::endl;
+          continue;
+        }
+
+        // check if a chess piece can move between the attacker and king.
+        std::string step = ChessPiecePosition::GetStep(chessPieceOpponent->GetPosition(), chessPieceKing->GetPosition());
+
+        // there is no direct way between attacker and king. so the attacker is the knight.
+        // in this case we can not defend the attack by moving a chess piece between attacker and king.
+        if (step.empty()) {
+          return true;
+        }
+
+        ChessPiecePosition currentPosition = chessPieceOpponent->GetPosition();
+        ChessPiecePosition* nextPosition = &currentPosition;
+
+        while (nextPosition = nextPosition->NextFromString(step)) {
+          if (*nextPosition == chessPieceKing->GetPosition()) break;
+
+          for (ChessPiece* chessPieceCurrent : this->GetChessPieces()) {
+            if (chessPieceCurrent->GetColor() == this->GetCurrentPlayer()->GetColor()) {
+              if (chessPieceCurrent->GetNextPositions().count(*nextPosition) == 1) {
+                isDefensibleAttack = true;
+                break;
+              }
+            }
+          }
+        }
+
+        if (isDefensibleAttack == false) {
+          return true;
+        }
+      }
+    }
+  }
+
+  return numberOfAttackers > 1;
+}
+
+/**
+ * Status whether the king of the current player is in check.
+ * @return Status whether the king of the current player is in check.
+ */
+bool Chessboard::IsInCheck() {
+  ChessPieceColor currentPlayerColor = this->GetCurrentPlayer()->GetColor();
+  ChessPiece* chessPieceKing = this->GetChessPieceKing(currentPlayerColor);
+
+  if (chessPieceKing == nullptr) {
+    throw std::domain_error("king is missing");
+  }
+
+  // 3.9    The king in check:
+  // 3.9.1    The king is said to be "in check" if it is attacked by one or more of the opponent's pieces, even if such pieces are
+  //          constrained from moving to the square occupied by the king because they would then leave or place their own king in check.
+  // 3.9.2    No piece can be moved that will either expose the king of the same colour to check or leave that king in check.
+  for (std::pair<ChessPiecePosition, ChessPiece*> field : this->chessboard) {
+    if (field.second->GetColor() == this->GetOpponentPlayer()->GetColor()) {
+      if (field.second->GetNextPositions().count(chessPieceKing->GetPosition()) == 1) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Status whether the match ends with a draw because of stalemate.
+ * @return Status whether the match ends with a draw because of stalemate.
+ */
+bool Chessboard::IsStalemate() {
+  ChessPieceColor currentPlayerColor = this->GetCurrentPlayer()->GetColor();
+  ChessPieceColor opponentPlayerColor = this->GetOpponentPlayer()->GetColor();
+  ChessPiece* chessPieceKing = this->GetChessPieceKing(currentPlayerColor);
+
+  if (chessPieceKing == nullptr) {
+    throw std::domain_error("king is missing");
+  }
+
+  // 5.2.1  The game is drawn when the player to move has no legal move and his/her king is not in check.
+  //        The game is said to end in "stalemate". This immediately ends the game.
+  for (std::pair<ChessPiecePosition, ChessPiece*> field : this->chessboard) {
+    if (field.second->GetColor() == currentPlayerColor) {
+      if (field.second->GetNextPositions().size() > 0) {
+        return false;
+      }
+    }
+  }
+
+  if (this->IsInCheck()) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Sets a chess piece on the chessboard.
+ * If there is already a chess piece on the field, the chess piece will be deleted.
+ * @param chesspiece A pointer to the chess piece which is to be set.
+ */
 void Chessboard::SetChessPiece(ChessPiece* chesspiece) {
   this->chessboard[chesspiece->GetPosition()] = chesspiece;
 }
 
+/**
+ * Sets the move to the history.
+ * @param move The move to be added to the history.
+ */
+void Chessboard::SetToHistory(ChessPieceMove move) {
+  this->_historyMoves.push_back(move);
+}
+
+/**
+ * Sets the source and target position to the history.
+ * @param fromPosition The source position to be added to the history.
+ * @param toPosition The target position to be added to the history.
+ */
+void Chessboard::SetToHistory(ChessPiecePosition fromPosition, ChessPiecePosition toPosition) {
+  this->_historyPositions.push_back({fromPosition, toPosition});
+}
+
+/**
+ * Switches the current player.
+ */
+void Chessboard::SwitchCurrentPlayer() {
+  this->currentPlayer = this->GetOpponentPlayer();
+}
+
+
+
+
+
+
+
+
+void Chessboard::RemoveChessPiece(ChessPiecePosition position) {
+  if (this->chessboard.count(position) == 1) {
+    delete this->chessboard[position];
+    this->chessboard.erase(position);
+  }
+}
+
+
 bool Chessboard::IsEmptyField(ChessPiecePosition* position) {
   return (this->chessboard.count(*position) == 0);
 }
@@ -15,41 +313,212 @@ ChessPiece* Chessboard::GetChessPiece(ChessPiecePosition* position) {
 
 
 
-void Chessboard::MoveChessPiece(std::string move) {
+bool Chessboard::MoveCastling(ChessPieceColor color, bool shortCastling) {
-  if (move.length() == 5) {
+  ChessPiecePosition fromPositionKing = (color == ChessPieceColor::White) ? ChessPiecePosition("E1") : ChessPiecePosition("E8");
-    ChessPiecePosition* fromPosition = new ChessPiecePosition(move.substr(0, 2));
+  ChessPiecePosition fromPositionRook = (color == ChessPieceColor::White) ? ChessPiecePosition(shortCastling ? "H1" : "A1") : ChessPiecePosition(shortCastling ? "H8" : "A8");
-    ChessPiecePosition* toPosition = new ChessPiecePosition(move.substr(3, 2));
+  ChessPiecePosition toPositionKing = (color == ChessPieceColor::White) ? ChessPiecePosition(shortCastling ? "G1" : "C1") : ChessPiecePosition(shortCastling ? "G8" : "C8");
+  ChessPiecePosition toPositionRook = (color == ChessPieceColor::White) ? ChessPiecePosition(shortCastling ? "F1" : "D1") : ChessPiecePosition(shortCastling ? "F8" : "D8");
 
-    ChessPiece* piece = this->GetChessPiece(fromPosition);
+  ChessPiece* chessPieceRook = this->GetChessPiece(&fromPositionRook);
+  ChessPiece* chessPieceKing = this->GetChessPiece(&fromPositionKing);
 
-    if (piece->GetColor() != this->GetCurrentPlayer()->GetColor()) {
+  if (chessPieceKing == nullptr || chessPieceRook == nullptr) {
-      return; // wrong player
+    return false;
-    }
+  }
 
-    if (piece->GetNextPositions().count(*toPosition) == 1) {
+  if (chessPieceKing->IsKing() == false || chessPieceRook->IsRook() == false) {
-      this->chessboard[*toPosition] = this->chessboard[*fromPosition];
+    return false;
-      this->chessboard.erase(*fromPosition);
+  }
-      piece->SetPosition(*toPosition);
+
-      this->SetToHistory(*fromPosition, *toPosition);
+  if (chessPieceKing->IsFirstMove() == false || chessPieceRook->IsFirstMove() == false) {
+    return false;
+  }
+
+  std::string step = ChessPiecePosition::GetStep(chessPieceKing->GetPosition(), toPositionKing);
+  ChessPiecePosition currentPosition = chessPieceKing->GetPosition();
+  ChessPiecePosition* nextPosition = &currentPosition;
+  while (nextPosition = nextPosition->NextFromString(step)) {
+    if (this->IsEmptyField(nextPosition)) {
+      for (std::pair<ChessPiecePosition, ChessPiece*> field : this->chessboard) {
+        if (field.second->GetColor() != color) {
+          if (field.second->GetNextPositions().count(*nextPosition) == 0) {
+            continue;
+          } else {
+            return false;
+          }
+        }
+      }
+      if (nextPosition->ToString() == toPositionKing.ToString()) {
+        break;
+      }
     } else {
-      return; // wrong or invalid move
+      return false;
     }
   }
 
+  this->chessboard[toPositionKing] = chessPieceKing;
+  this->chessboard.erase(chessPieceKing->GetPosition());
+  this->SetToHistory(chessPieceKing->GetPosition(), toPositionKing);
+  chessPieceKing->SetPosition(toPositionKing);
+  this->chessboard[toPositionRook] = chessPieceRook;
+  this->chessboard.erase(chessPieceRook->GetPosition());
+  this->SetToHistory(chessPieceRook->GetPosition(), toPositionRook);
+  chessPieceRook->SetPosition(toPositionRook);
+  return true;
+}
+
+void Chessboard::MoveChessPiece(std::string move) {
+  ChessPieceMove chessPieceMove = ChessPieceMove(move);
+
+  if (chessPieceMove.IsValidShortNotation() == false) {
+    return;
+  }
+
+  if (chessPieceMove.IsShortCastling()) {
+    this->MoveCastling(this->GetCurrentPlayer()->GetColor(), true);
+  } else if (chessPieceMove.IsLongCastling()) {
+    this->MoveCastling(this->GetCurrentPlayer()->GetColor(), false);
+  } else if (chessPieceMove.IsDrawOffer()) {
+    // Remis
+  } else {
+    ChessPiece* chessPiece = nullptr;
+    ChessPiecePosition toChessPiecePosition = ChessPiecePosition(chessPieceMove.GetToPositionFile(), chessPieceMove.GetToPositionRank());
+    char fromPositionFile = chessPieceMove.GetFromPositionFile();
+    int fromPositionRank = chessPieceMove.GetFromPositionRank();
+
+    for (std::pair<ChessPiecePosition, ChessPiece*> field : this->chessboard) {
+      if (field.second->GetColor() == this->GetCurrentPlayer()->GetColor()) {
+        if (field.second->GetChar() == chessPieceMove.GetChessPieceChar() && field.second->GetNextPositions().count(toChessPiecePosition) == 1) {
+
+          if (fromPositionFile >= 'a' && fromPositionFile <= 'h') {
+            if (field.second->GetPosition().GetFile() == std::toupper(fromPositionFile)) {
+              chessPiece = field.second;
+              break;
+            } else {
+              continue;
+            }
+          }
+
+          if (fromPositionRank >= 1 && fromPositionRank <= 8) {
+            if (field.second->GetPosition().GetRank() == fromPositionRank) {
+              chessPiece = field.second;
+              break;
+            } else {
+              continue;
+            }
+          }
+
+          chessPiece = field.second;
+          break;
+        }
+      }
+    }
+
+    if (chessPiece) {
+      if (this->IsEmptyField(&toChessPiecePosition) == false) {
+        this->RemoveChessPiece(toChessPiecePosition);
+        this->chessboard[toChessPiecePosition] = this->chessboard[chessPiece->GetPosition()];
+        this->chessboard.erase(chessPiece->GetPosition());
+        this->SetToHistory(chessPiece->GetPosition(), toChessPiecePosition);
+        chessPiece->SetPosition(toChessPiecePosition);
+      } else {
+        if (chessPiece->IsPawn()) {
+          if (chessPiece->GetColor() == ChessPieceColor::White) {
+            std::string difference = ChessPiecePosition::GetDifference(chessPiece->GetPosition(), toChessPiecePosition);
+
+            if (difference == "T1L1" || difference == "T1R1") {
+              ChessPiecePosition currentPosition = toChessPiecePosition;
+              ChessPiecePosition* nextPosition = &currentPosition;
+
+              if (nextPosition = nextPosition->NextBottom()) {
+                if (this->IsEmptyField(nextPosition) == false) {
+                  ChessPiece* chessPieceRemove = this->GetChessPiece(nextPosition);
+
+                  if (chessPieceRemove->GetColor() != chessPiece->GetColor() && chessPieceRemove->IsPawn()) {
+                    this->chessboard[toChessPiecePosition] = this->chessboard[chessPiece->GetPosition()];
+                    this->chessboard.erase(chessPiece->GetPosition());
+                    this->SetToHistory(chessPiece->GetPosition(), toChessPiecePosition);
+                    chessPiece->SetPosition(toChessPiecePosition);
+                    this->RemoveChessPiece(chessPieceRemove->GetPosition());
+                  }
+                }
+              }
+            } else {
+              this->chessboard[toChessPiecePosition] = this->chessboard[chessPiece->GetPosition()];
+              this->chessboard.erase(chessPiece->GetPosition());
+              this->SetToHistory(chessPiece->GetPosition(), toChessPiecePosition);
+              chessPiece->SetPosition(toChessPiecePosition);
+            }
+          } else if (chessPiece->GetColor() == ChessPieceColor::Black) {
+            std::string difference = ChessPiecePosition::GetDifference(chessPiece->GetPosition(), toChessPiecePosition);
+
+            if (difference == "B1L1" || difference == "B1R1") {
+              ChessPiecePosition currentPosition = toChessPiecePosition;
+              ChessPiecePosition* nextPosition = &currentPosition;
+
+              if (nextPosition = nextPosition->NextTop()) {
+                if (this->IsEmptyField(nextPosition) == false) {
+                  ChessPiece* chessPieceRemove = this->GetChessPiece(nextPosition);
+
+                  if (chessPieceRemove->GetColor() != chessPiece->GetColor() && chessPieceRemove->IsPawn()) {
+                    this->chessboard[toChessPiecePosition] = this->chessboard[chessPiece->GetPosition()];
+                    this->chessboard.erase(chessPiece->GetPosition());
+                    this->SetToHistory(chessPiece->GetPosition(), toChessPiecePosition);
+                    chessPiece->SetPosition(toChessPiecePosition);
+                    this->RemoveChessPiece(chessPieceRemove->GetPosition());
+                  }
+                }
+              }
+            } else {
+              this->chessboard[toChessPiecePosition] = this->chessboard[chessPiece->GetPosition()];
+              this->chessboard.erase(chessPiece->GetPosition());
+              this->SetToHistory(chessPiece->GetPosition(), toChessPiecePosition);
+              chessPiece->SetPosition(toChessPiecePosition);
+            }
+          }
+        } else {
+          this->chessboard[toChessPiecePosition] = this->chessboard[chessPiece->GetPosition()];
+          this->chessboard.erase(chessPiece->GetPosition());
+          this->SetToHistory(chessPiece->GetPosition(), toChessPiecePosition);
+          chessPiece->SetPosition(toChessPiecePosition);
+        }
+      }
+
+      if (chessPieceMove.GetPromotionChessPieceChar() != '\0') {
+        ChessPieceColor color = chessPiece->GetColor();
+        this->RemoveChessPiece(toChessPiecePosition);
+
+        switch (chessPieceMove.GetPromotionChessPieceChar()) {
+          case 'R':
+            this->chessboard[toChessPiecePosition] = new Rook(color, toChessPiecePosition);
+            break;
+          case 'B':
+            this->chessboard[toChessPiecePosition] = new Bishop(color, toChessPiecePosition);
+            break;
+          case 'N':
+            this->chessboard[toChessPiecePosition] = new Knight(color, toChessPiecePosition);
+            break;
+          case 'Q':
+            this->chessboard[toChessPiecePosition] = new Queen(color, toChessPiecePosition);
+            break;
+        }
+      }
+    }
+  }
+
+  this->SetToHistory(chessPieceMove);
   this->UpdateChessPieces();
   this->SwitchCurrentPlayer();
 }
 
-void Chessboard::SetToHistory(ChessPiecePosition fromPosition, ChessPiecePosition toPosition) {
+
-  this->history.push_back({fromPosition, toPosition});
-}
 
 int Chessboard::GetCountMoves() {
-  return this->history.size();
+  return this->_historyPositions.size();
 }
 
-std::pair<ChessPiecePosition, ChessPiecePosition> Chessboard::GetLastMove() {
+std::pair<ChessPiecePosition, ChessPiecePosition> Chessboard::GetLastMovePositions() {
-  return this->history.back();
+  return this->_historyPositions.back();
 }
 
 std::vector<ChessPiece*> Chessboard::GetChessPieces() {
@@ -62,157 +531,9 @@ std::vector<ChessPiece*> Chessboard::GetChessPieces() {
   return chessPieces;
 }
 
-bool Chessboard::IsCheck() {
-  ChessPiece* chessPieceKing = this->GetChessPieceKing(this->GetCurrentPlayer()->GetColor());
-
-  for (std::pair<ChessPiecePosition, ChessPiece*> field : this->chessboard) {
-    if (field.second->GetColor() == this->GetOpponentPlayer()->GetColor()) {
-      if (field.second->GetNextPositions().count(chessPieceKing->GetPosition()) == 1) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-bool Chessboard::IsCheckmate() {
-
-  if (this->IsCheck() == false) {
-    return false;
-  }
-
-  ChessPiece* chessPieceKing = this->GetChessPieceKing(this->GetCurrentPlayer()->GetColor());
-
-  if (chessPieceKing->GetNextPositions().size() > 0) {
-    return false;
-  }
 
 
-  int cntAttacker = 0;
 
-  for (ChessPiece* chessPieceOpponent : this->GetChessPieces()) {
-    if (chessPieceOpponent->GetColor() == this->GetOpponentPlayer()->GetColor()) {
-      if (chessPieceOpponent->GetNextPositions().count(chessPieceKing->GetPosition()) == 1) { // Is an attacker
-        cntAttacker++;
-
-        bool deniable = false;
-
-        // remove attacker
-        for (ChessPiece* chessPieceCurrent : this->GetChessPieces()) {
-          if (chessPieceCurrent->GetColor() == this->GetCurrentPlayer()->GetColor()) {
-            if (chessPieceCurrent->GetNextPositions().count(chessPieceOpponent->GetPosition()) == 1) {
-              deniable = true; // blocked attack because current player can remove attacker
-              break;
-            }
-          }
-        }
-
-        if (deniable == false) {
-          return true;
-        }
-
-        // move between attacker and king
-        // this is not possible for pawn, knight and king because they beat on next field.
-
-        std::string step = ChessPiecePosition::GetStep(chessPieceOpponent->GetPosition(), chessPieceKing->GetPosition());
-
-        ChessPiecePosition currentPosition = chessPieceOpponent->GetPosition();
-        ChessPiecePosition* nextPosition = &currentPosition;
-        deniable = false;
-
-        while (nextPosition = nextPosition->NextFromString(step)) {
-          for (ChessPiece* chessPieceCurrent : this->GetChessPieces()) {
-            if (chessPieceCurrent->GetColor() == this->GetCurrentPlayer()->GetColor()) {
-              if (chessPieceCurrent->GetNextPositions().count(*nextPosition) == 1) {
-                deniable = true; // blocked attack because current player can block between attacker and king
-                break;
-              }
-            }
-          }
-        }
-
-         if (deniable == false) {
-          return true;
-        }
-      }
-    }
-  }
-
-  if (cntAttacker > 1) {
-    return true;
-  }
-
-  return false;
-}
-
-bool Chessboard::IsStalemate() {
-  ChessPieceColor currentColor = this->GetCurrentPlayer()->GetColor();
-  ChessPieceColor opponentColor = this->GetOpponentPlayer()->GetColor();
-  ChessPiece* chessPieceKing;
-
-  for (std::pair<ChessPiecePosition, ChessPiece*> field : this->chessboard) {
-    if (field.second->IsKing() && field.second->GetColor() == currentColor) {
-      chessPieceKing = field.second;
-      break;
-    }
-  }
-
-  // Der König hat aber auch keine validen Züge mehr.
-  if (chessPieceKing->GetNextPositions().size() > 0) {
-    return false;
-  }
-
-  // Man hat selbst keine Figuren mehr welche noch ziehen könnten.
-  for (std::pair<ChessPiecePosition, ChessPiece*> field : this->chessboard) {
-    if (field.second->GetColor() == currentColor) {
-      if (field.second->GetNextPositions().size() > 0) {
-        return false;
-      }
-    }
-  }
-
-  // König wird nicht direkt attackiert.
-  for (std::pair<ChessPiecePosition, ChessPiece*> field : this->chessboard) {
-    if (field.second->GetColor() == opponentColor) {
-      if (field.second->GetNextPositions().count(chessPieceKing->GetPosition()) == 1) {
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
-/**
- * Get the current player.
- */
-Player* Chessboard::GetCurrentPlayer() {
-  return this->currentPlayer;
-}
-
-/**
- * Get the opponent player.
- */
-Player* Chessboard::GetOpponentPlayer() {
-  if (this->GetCurrentPlayer()->GetColor() == ChessPieceColor::Black) {
-    return this->GetPlayer(ChessPieceColor::White);
-  } else {
-    return this->GetPlayer(ChessPieceColor::Black);
-  }
-}
-
-/**
- * Get a player by color.
- * @return Player* The player who is associated with the given color.
- */
-Player* Chessboard::GetPlayer(ChessPieceColor color) {
-  if (color == ChessPieceColor::Black) {
-    return std::get<ChessPieceColor::Black>(this->players);
-  } else {
-    return std::get<ChessPieceColor::White>(this->players);
-  }
-}
 
 /**
  * Set the players to the chessboard.
@@ -236,16 +557,7 @@ void Chessboard::SetPlayers(Player* playerA, Player* playerB) {
   this->currentPlayer = this->GetPlayer(ChessPieceColor::White);
 }
 
-/**
+
- * Switch the current player.
- */
-void Chessboard::SwitchCurrentPlayer() {
-  if (this->GetCurrentPlayer()->GetColor() == ChessPieceColor::White) {
-    this->currentPlayer = this->GetPlayer(ChessPieceColor::Black);
-  } else {
-    this->currentPlayer = this->GetPlayer(ChessPieceColor::White);
-  }
-}
 
 /**
  * Update the next positions of all chess pieces.
@@ -268,15 +580,31 @@ void Chessboard::UpdateChessPieces() {
  */
 bool Chessboard::IsPositionUnderAttack(ChessPiecePosition position, ChessPieceColor color) {
   for (std::pair<ChessPiecePosition, ChessPiece*> field : this->chessboard) {
-    if (field.second->GetColor() == color && field.second->GetNextPositions().count(position) == 1) {
+    if (field.second->IsPawn() == false && field.second->GetColor() == color && field.second->GetNextPositions().count(position) == 1) {
       return true;
     }
   }
 
+  for (std::pair<ChessPiecePosition, ChessPiece*> field : this->chessboard) {
+    if (field.second->IsPawn() && field.second->GetColor() == color) {
+      std::string difference = ChessPiecePosition::GetDifference(field.second->GetPosition(), position);
+      if (color == ChessPieceColor::White && (difference == "T1L1" || difference == "T1R1")) {
+        return true;
+      } else if (color == ChessPieceColor::Black && (difference == "B1L1" || difference == "B1R1")) {
+        return true;
+      } else {
+        continue;
+      }
+    }
+  }
+
   return false;
 }
 
 Chessboard::~Chessboard() {
+  delete this->players.first;
+  delete this->players.second;
+
   for (std::pair<ChessPiecePosition, ChessPiece*> field : this->chessboard) {
     delete field.second;
   }
@@ -294,3 +622,44 @@ ChessPiece* Chessboard::GetChessPieceKing(ChessPieceColor color) {
 
   return chessPieceKing;
 }
+
+
+
+bool Chessboard::ExportFilePGN(std::string filePath) {
+  std::string moveList;
+  std::vector<ChessPieceMove> moves = this->GetHistoryMoves();
+
+  time_t timestamp = time(NULL);
+  struct tm datetime = *localtime(&timestamp);
+  char output[50];
+  strftime(output, 50, "%Y.%m.%d", &datetime);
+
+/**
+
+[Result "1/2-1/2"]
+
+[ECO "A29"]
+[WhiteElo "2750"]
+[BlackElo "2595"]
+[PlyCount "155"]
+   */
+
+  moveList.append("[Date \"").append(output).append("\"]").append("\n");
+  moveList.append("[White \"").append(this->GetPlayer(ChessPieceColor::White)->GetName()).append("\"]").append("\n");
+  moveList.append("[Black \"").append(this->GetPlayer(ChessPieceColor::Black)->GetName()).append("\"]").append("\n");
+
+
+  for (int moveIndex = 0; moveIndex < moves.size() - 1; moveIndex++) {
+    if (moveIndex % 6 == 0) {
+      moveList.append("\n");
+    }
+    if (moveIndex % 2 == 0) {
+      moveList.append(std::to_string((moveIndex / 2) + 1)).append(".");
+    }
+    moveList.append(" ").append(moves[moveIndex].ToString()).append(" ");
+  }
+
+  std::cout << moveList;
+  return true;
+
+}

Chessboard/Chessboard.hpp

@@ -1,38 +1,49 @@
 #ifndef Chessboard_H
 #define Chessboard_H
 
+#include <ctime>
+#include <fstream>
 #include <iostream>
 #include <map>
 #include <random>
+#include <regex>
 #include <string>
 #include <utility>
 #include <vector>
 #include "../Player/Player.hpp"
 #include "../ChessPieces/ChessPieceColor.hpp"
+#include "../ChessPieces/ChessPieceMove.hpp"
 #include "../ChessPieces/ChessPiecePosition.hpp"
 
 class ChessPiece;
 
 class Chessboard {
   private:
+    std::vector<ChessPieceMove> _historyMoves;
+    std::vector<std::pair<ChessPiecePosition, ChessPiecePosition>> _historyPositions;
     std::map<ChessPiecePosition, ChessPiece*> chessboard;
-    std::vector<std::pair<ChessPiecePosition, ChessPiecePosition>> history;
     std::pair<Player*, Player*> players;
     Player* currentPlayer;
+    void RemoveChessPiece(ChessPiecePosition position);
 
   public:
     ~Chessboard();
+    std::vector<ChessPieceMove> GetHistoryMoves();
+    std::vector<std::pair<ChessPiecePosition, ChessPiecePosition>> GetHistoryPositions();
     void SetChessPiece(ChessPiece* chesspiece);
     bool IsEmptyField(ChessPiecePosition* position);
     ChessPiece* GetChessPiece(ChessPiecePosition* position);
     std::vector<ChessPiece*> GetChessPieces();
     void UpdateChessPieces();
     void MoveChessPiece(std::string move);
+    bool MoveCastling(ChessPieceColor color, bool shortCastling);
+    void SetToHistory(ChessPieceMove move);
     void SetToHistory(ChessPiecePosition fromPosition, ChessPiecePosition toPosition);
     int GetCountMoves();
-    std::pair<ChessPiecePosition, ChessPiecePosition> GetLastMove();
+    bool HasMoves();
+    std::pair<ChessPiecePosition, ChessPiecePosition> GetLastMovePositions();
     bool IsCheckmate();
-    bool IsCheck();
+    bool IsInCheck();
     bool IsStalemate();
     bool IsPositionUnderAttack(ChessPiecePosition position, ChessPieceColor color);
     Player* GetCurrentPlayer();
@@ -41,6 +52,8 @@ class Chessboard {
     void SwitchCurrentPlayer();
     Player* GetPlayer(ChessPieceColor color);
     ChessPiece* GetChessPieceKing(ChessPieceColor color);
+    bool ImportFilePGN(std::string filePath);
+    bool ExportFilePGN(std::string filePath);
 };
 
 #endif

README.md

@@ -92,18 +92,30 @@
 
 ## ToDo
 - Speicherfunktion
-- Schachnotation (Lange)
 - Menü (ASCII Art of TurboSchach)
   - Startmenü
   - Spielmenü mit Historie, Kommand
   - Plattformunabhängiges CMD clearing vor dem Zeichnen
-- Spezialbewegung (Rochade, Umwandlung, En passant)
 
-## Build
+## Kompilieren und Ausführen
+Um TurboSchach kompilieren zu können wird mindestens C++ 17 benötigt.
+
+### Windows
+
 ```
-g++ -o chess.exe main.cpp ChessPieces/*.cpp Chessboard/*.cpp Player/*.cpp
+g++ -std=c++17 -o chess.exe main.cpp ChessPieces/*.cpp Chessboard/*.cpp Player/*.cpp
+./chess.exe
 ```
 
-## Voraussetzungen
+### Linux und MacOS
 
-- C++ 17
+```
+# compile the project
+make
+
+# run the project
+make run
+
+# remove all output files
+make clean
+```

chessgames/1229276.pgn

@@ -0,0 +1,27 @@
+[Event "Bosna 21st"]
+[Site "Sarajevo YUG"]
+[Date "1982.??.??"]
+[EventDate "1983.03.00"]
+[Round "?"]
+[Result "0-1"]
+[White "Vitomir Arapovic"]
+[Black "Alexander Beliavsky"]
+[ECO "C26"]
+[WhiteElo "?"]
+[BlackElo "?"]
+[PlyCount "150"]
+
+1.e4 e5 2.Nc3 Nf6 3.Bc4 Bc5 4.d3 O-O 5.Nf3 Re8 6.Ng5 Re7 7.O-O
+h6 8.Nf3 c6 9.d4 exd4 10.e5 Ne8 11.Nxd4 d5 12.exd6 Nxd6 13.Bb3
+Na6 14.Be3 Qe8 15.Qf3 Bxd4 16.Bxd4 Nf5 17.Rad1 Bd7 18.Qh5 b6
+19.Qg6 Nxd4 20.Rxd4 Nc5 21.Bc4 Be6 22.Qg3 Bxc4 23.Rxc4 Rd8
+24.Rg4 f5 25.Rg6 Rd4 26.Rd6 f4 27.Qg6 Qxg6 28.Rxg6 Ne6 29.h4
+h5 30.g4 fxg3 31.Rxg3 Rf7 32.Re1 Nc5 33.Re8+ Kh7 34.Rg5 Rxh4
+35.b4 Nd7 36.Ne4 Nf6 37.Nxf6+ Rxf6 38.Re7 Rg6 39.Rxg6 Kxg6
+40.Re6+ Kh7 41.a3 Rc4 42.Re7 Rxc2 43.Rxa7 Rc4 44.Kg2 b5 45.Ra6
+g6 46.Ra8 Kh6 47.Rh8+ Kg5 48.Rg8 Kf5 49.Rf8+ Kg4 50.Rf6 g5
+51.Rf8 Rc3 52.Ra8 h4 53.a4 h3+ 54.Kh2 Rc2 55.Kg1 Rb2 56.axb5
+cxb5 57.Ra3 Kh4 58.Rd3 Rxb4 59.Kh2 g4 60.Rd5 Rb2 61.Kg1 Rb1+
+62.Kh2 Rf1 63.Rxb5 Rxf2+ 64.Kg1 Rc2 65.Rb4 Re2 66.Ra4 Kg3
+67.Ra1 Re3 68.Kh1 Kf3 69.Rf1+ Ke2 70.Rf8 g3 71.Kg1 Re4 72.Rh8
+Kf3 73.Rf8+ Rf4 74.Rg8 Rf7 75.Rh8 h2+ 0-1

chessgames/1258478.pgn

@@ -0,0 +1,29 @@
+[Event "Wch-blitz"]
+[Site "Saint John CAN"]
+[Date "1988.02.20"]
+[EventDate "1988.02.19"]
+[Round "3"]
+[Result "1/2-1/2"]
+[White "Garry Kasparov"]
+[Black "Kiril Dimitrov Georgiev"]
+[ECO "A29"]
+[WhiteElo "2750"]
+[BlackElo "2595"]
+[PlyCount "155"]
+
+1. c4 e5 2. Nc3 Nf6 3. Nf3 Nc6 4. g3 d5 5. cxd5 Nxd5 6. Bg2
+Nb6 7. O-O Be7 8. a3 a5 9. d3 O-O 10. Be3 Be6 11. Na4 Nd5
+12. Bc5 Bd6 13. Rc1 h6 14. Nd2 Rc8 15. Ne4 b6 16. Nxd6 cxd6
+17. Bxb6 Nxb6 18. Rxc6 Rb8 19. Nxb6 Rxb6 20. Qc2 Qb8 21. Rxb6
+Qxb6 22. Rb1 Bb3 23. Qd2 Rb8 24. Rc1 Be6 25. Rc2 d5 26. h4 a4
+27. Bf3 Qd4 28. e3 Qb6 29. d4 e4 30. Be2 Qb3 31. Kg2 g6
+32. Bd1 Kg7 33. Qc1 Qb6 34. Rd2 Bd7 35. Qc5 Qxc5 36. dxc5 Bc6
+37. Kf1 Kf6 38. Ke1 Ke5 39. Rc2 Rb5 40. Kd2 d4 41. exd4+ Kxd4
+42. Be2 Rxc5 43. Rxc5 Kxc5 44. Ke3 f5 45. g4 Kd5 46. gxf5 gxf5
+47.Kf4 Ke6 48. Bc4+ Kf6 49. b4 axb3 50. Bxb3 Bb5 51.a4 Ba6
+52.Bd5 Bc8 53.Bc6 Ke6 54.Bb5 Kd6 55. Bf1 Kc5 56.Bh3 Kb4
+57.Bxf5 Ba6 58.Bxe4 Kxa4 59.Ke5 Kb4 60. f4 Kc5 61.f5 Bc4 62.f6
+Bf7 63.Bf5 Kc6 64.Be6 Bg6 65.f7 Bxf7 66. Bxf7 Kd7 67.Kf6 Kd6
+68.h5 Kd7 69.Kg6 Ke7 70.Ba2 Ke8 71. Kxh6 Kf8 72.Kg6 Ke7 73.h6
+Kd6 74.h7 Kc5 75.h8=Q Kb4 76. Qd4+ Kb5 77.Bd5 Ka6 78.Qc5
+1/2-1/2

chessgames/1284086.pgn

@@ -0,0 +1,22 @@
+[Event "Alicante"]
+[Site "Spain"]
+[Date "1992.??.??"]
+[EventDate "?"]
+[Round "7"]
+[Result "1/2-1/2"]
+[White "Stephen Boyd"]
+[Black "Torbjorn Glimbrant"]
+[ECO "C49"]
+[WhiteElo "2265"]
+[BlackElo "2235"]
+[PlyCount "91"]
+
+1.e4 e5 2.Nf3 Nc6 3.Nc3 Nf6 4.Bb5 Bb4 5.O-O O-O 6.d3 d6 7.Bg5
+Bxc3 8.bxc3 Qe7 9.Re1 Nd8 10.d4 h6 11.Bc1 a6 12.Bd3 Bg4 13.h3
+Bd7 14.a4 a5 15.Nh4 Nc6 16.Nf5 Bxf5 17.exf5 Qd7 18.g4 exd4
+19.cxd4 Nxd4 20.Bb2 c5 21.Bxd4 cxd4 22.Bb5 Qc7 23.Qxd4 d5
+24.Re2 Rad8 25.Rae1 Rd6 26.Re7 Qxc2 27.Rxb7 Ne4 28.Re2 Qc1+
+29.Kg2 Qc8 30.Re7 Qd8 31.Qa7 Nf6 32.Rc7 d4 33.Ree7 d3 34.Rxf7
+Rxf7 35.Rxf7 d2 36.Rxg7+ Kh8 37.Be2 d1=Q 38.Bxd1 Rxd1 39.Rg6
+Qd5+ 40.Kg3 Rd3+ 41.Kh4 Rxh3+ 42.Kxh3 Qh1+ 43.Kg3 Nh5+ 44.gxh5
+Qf3+ 45.Kh2 Qg2+ 46.Kxg2 1/2-1/2

chessgames/1348060.pgn

@@ -0,0 +1,21 @@
+[Event "Norwegian Championship"]
+[Site "Sandnes NOR"]
+[Date "2005.07.05"]
+[EventDate "2005.07.??"]
+[Round "5"]
+[Result "1-0"]
+[White "Magnus Carlsen"]
+[Black "Geir Sune Tallaksen Ostmoe"]
+[ECO "E15"]
+[WhiteElo "2528"]
+[BlackElo "2349"]
+[PlyCount "73"]
+
+1. Nf3 Nf6 2. c4 e6 3. d4 b6 4. g3 Ba6 5. b3 b5 6. cxb5 Bxb5
+7. Bg2 d5 8. O-O Nbd7 9. Nc3 Ba6 10. Re1 Bd6 11. Bb2 O-O
+12. e4 Nxe4 13. Nxe4 dxe4 14. Rxe4 Bb7 15. Rh4 Be7 16. Rh3 Nf6
+17. Qe2 Bd5 18. Re1 Qb8 19. Ne5 Qb7 20. Bxd5 Qxd5 21. Qc2 c5
+22. Ng4 h6 23. Re5 Qf3 24. Nxh6+ gxh6 25. Rxh6 Kg7 26. Rg5+
+Kxh6 27. Bc1 cxd4 28. Rg4+ Qe3 29. Rh4+ Nh5 30. Rxh5+ Kxh5
+31. Qh7+ Kg4 32. fxe3 Rac8 33. Kg2 Rxc1 34. h3+ Kg5 35. Qg7+
+Kf5 36. g4+ Ke4 37. Qxd4# 1-0

chessgames/1427255.pgn

@@ -0,0 +1,31 @@
+[Event "Youth - Experience"]
+[Site "Amsterdam NED"]
+[Date "2006.08.27"]
+[EventDate "2006.08.19"]
+[Round "8"]
+[Result "1/2-1/2"]
+[White "Ulf Andersson"]
+[Black "Daniel Stellwagen"]
+[ECO "A04"]
+[WhiteElo "2542"]
+[BlackElo "2575"]
+[PlyCount "175"]
+
+1. Nf3 f5 2. d4 g6 3. g3 Bg7 4. Bg2 Nf6 5. O-O O-O 6. c4 d6
+7. Nc3 Qe8 8. d5 a5 9. Nd4 Na6 10. e4 fxe4 11. Nxe4 Nxe4
+12. Bxe4 Bh3 13. Re1 Nc5 14. Bh1 Qf7 15. Be3 Rae8 16. Qd2 b6
+17. b3 Kh8 18. Rad1 e5 19. dxe6 Nxe6 20. Bd5 Nxd4 21. Bxd4 Qd7
+22. a3 Bxd4 23. Qxd4+ Qg7 24. Qxg7+ Kxg7 25. Bc6 Rxe1+
+26. Rxe1 g5 27. f3 Bf5 28. Kf2 Kf6 29. b4 axb4 30. axb4 Be6
+31. Re4 Bf5 32. Rd4 Rf7 33. b5 Re7 34. Bd5 Be6 35. f4 Bxd5
+36. fxg5+ Kxg5 37. Rxd5+ Kg6 38. Kf3 Re1 39. h4 h5 40. Rg5+
+Kh6 41. g4 hxg4+ 42. Rxg4 Re5 43. Rd4 Rc5 44. Ke4 Kg6 45. Kd3
+Rh5 46. Rg4+ Kf6 47. Kd4 Ke6 48. Re4+ Kf6 49. Rg4 Ke6 50. Rf4
+Ke7 51. Ke4 Re5+ 52. Kf3 d5 53. Rd4 Re1 54. Rxd5 Rc1 55. Rd4
+Kf6 56. Ke4 Ke6 57. Kd3 Rd1+ 58. Kc3 Rc1+ 59. Kd2 Rh1 60. Re4+
+Kf6 61. Ke3 Rc1 62. Rg4 Kf5 63. Rg5+ Kf6 64. Kd4 Rh1 65. Rg4
+Ke6 66. Ke4 Re1+ 67. Kf3 Rc1 68. Ke3 Kf5 69. Rd4 Ke5 70. Rd5+
+Ke6 71. Kd3 Rd1+ 72. Ke4 Rh1 73. h5 Rh4+ 74. Kd3 Rh3+ 75. Kd4
+Rh4+ 76. Kc3 Rh3+ 77. Kb4 Rg3 78. Rd8 Rh3 79. Rh8 Kd7 80. h6
+c5+ 81. bxc6+ Kxc6 82. Rh7 Rh4 83. Kb3 Kc5 84. Rc7+ Kd6
+85. Rh7 Kc5 86. Rc7+ Kd6 87. Rb7 Kc6 88. Rh7 1/2-1/2

chessgames/1482551.pgn

@@ -0,0 +1,29 @@
+[Event "Gibraltar Chess Festival"]
+[Site "Gibraltar ENG"]
+[Date "2008.01.23"]
+[EventDate "2008.01.22"]
+[Round "2"]
+[Result "1-0"]
+[White "Tim Jaksland"]
+[Black "Line Jin Jorgensen"]
+[ECO "C01"]
+[WhiteElo "2294"]
+[BlackElo "1867"]
+[PlyCount "149"]
+
+1. e4 e6 2. d4 d5 3. exd5 exd5 4. Nf3 Nf6 5. Bd3 Bd6 6. O-O
+O-O 7. c4 c6 8. Nc3 Bg4 9. h3 Bh5 10. Re1 dxc4 11. Bxc4 Qc7
+12. g4 Bg6 13. Ne5 Nfd7 14. f4 Nxe5 15. dxe5 Bc5+ 16. Kg2 h6
+17. f5 Bh7 18. Qf3 Kh8 19. Bf4 b5 20. Bb3 Qb6 21. Rad1 a5
+22. a4 Ra7 23. Re2 b4 24. Ne4 Bd4 25. Rxd4 Qxd4 26. Rd2 Qb6
+27. Be3 Qc7 28. Bc5 Nd7 29. Rxd7 Qxd7 30. Bxf8 Qd4 31. Bc5
+Qxb2+ 32. Qf2 Qxf2+ 33. Kxf2 Rd7 34. Nd6 Bg8 35. Ke3 Re7
+36. Kf4 Rxe5 37. Kxe5 f6+ 38. Kd4 Bxb3 39. Bb6 Bxa4 40. Bxa5
+h5 41. gxh5 Bd1 42. h6 b3 43. hxg7+ Kxg7 44. Bc3 Kh6 45. Ke4
+Kh5 46. Bxf6 b2 47. Bxb2 Kh4 48. f6 Bb3 49. Ke5 Kxh3 50. f7
+Bxf7 51. Nxf7 c5 52. Nd6 c4 53. Kf4 c3 54. Bxc3 Kg2 55. Ne4
+Kh2 56. Kf3 Kg1 57. Nf2 Kh2 58. Be5+ Kg1 59. Bd6 Kf1 60. Bh2
+Ke1 61. Ne4 Kf1 62. Nd2+ Ke1 63. Ke3 Kd1 64. Kd3 Ke1 65. Bg3+
+Kd1 66. Bf2 Kc1 67. Nc4 Kd1 68. Nb2+ Kc1 69. Kc3 Kb1 70. Kb3
+Ka1 71. Be3 Kb1 72. Bf4 Ka1 73. Nc4 Kb1 74. Na3+ Ka1 75. Be5+
+1-0

chessgames/1588906.pgn

@@ -0,0 +1,18 @@
+[Event "BCF-ch 87th"]
+[Site "Street ENG"]
+[Date "2000.08.09"]
+[EventDate "2000.07.31"]
+[Round "9"]
+[Result "0-1"]
+[White "Jack Rudd"]
+[Black "Martin Simons"]
+[ECO "B01"]
+[WhiteElo "2176"]
+[BlackElo "2226"]
+[PlyCount "40"]
+
+1. e4 d5 2. exd5 Nf6 3. c4 e6 4. dxe6 Bxe6 5. d4 Bb4+ 6. Bd2
+Bxd2+ 7. Qxd2 Qe7 8. Qe2 Nc6 9. Nf3 O-O-O 10. d5 Rhe8 11. Kd1
+Nxd5 12. cxd5 Bxd5 13. Nfd2 Qf6 14. Qd3 Bxg2 15. Qg3 Bxh1
+16. Nc3 Bf3+ 17. Kc1 Re1+ 18. Kc2 Nd4+ 19. Kd3 Nb3+ 20. Kc2
+Nxa1# 0-1

chessgames/1775611.pgn

@@ -0,0 +1,21 @@
+[Event "Isle of Man Masters"]
+[Site "Douglas IMN"]
+[Date "2014.10.11"]
+[EventDate "2014.10.04"]
+[Round "8.2"]
+[Result "0-1"]
+[White "Gabriel Sargissian"]
+[Black "Nigel Short"]
+[ECO "A70"]
+[WhiteElo "2690"]
+[BlackElo "2646"]
+[PlyCount "78"]
+
+1. d4 Nf6 2. c4 e6 3. Nf3 c5 4. d5 exd5 5. cxd5 d6 6. Nc3 g6
+7. Bf4 a6 8. a4 Bg7 9. h3 O-O 10. e3 Ne8 11. Be2 Nd7 12. O-O
+Rb8 13. Nd2 Ne5 14. a5 f5 15. Bg3 Bd7 16. Qb3 b5 17. axb6 Rxb6
+18. Qc2 Bb5 19. Nxb5 axb5 20. Nb3 g5 21. Na5 f4 22. Bh2 Nc7
+23. Rfd1 Kh8 24. Qe4 Qf6 25. exf4 gxf4 26. Nb3 Na6 27. Nd2 c4
+28. Qb1 Nc5 29. Ne4 Nxe4 30. Qxe4 Rb7 31. Ra5 Nd7 32. b4 cxb3
+33. Bd3 Qh6 34. Qb4 Nc5 35. Bb1 Be5 36. Rxb5 Rg7 37. Be4 Nxe4
+38. Qxe4 Qxh3 39. Kh1 Qh5 0-1

chessgames/1799484.pgn

@@ -0,0 +1,19 @@
+[Event "Russian Championship Superfinal"]
+[Site "Chita RUS"]
+[Date "2015.08.12"]
+[EventDate "2015.08.09"]
+[Round "4"]
+[Result "0-1"]
+[White "Peter Svidler"]
+[Black "Denis Khismatullin"]
+[ECO "B91"]
+[WhiteElo "2739"]
+[BlackElo "2642"]
+[PlyCount "58"]
+
+1. e4 c5 2. Nc3 a6 3. Nge2 d6 4. g3 g6 5. d4 cxd4 6. Nxd4 Bg7
+7. Bg2 Nf6 8. b3 O-O 9. Bb2 Bd7 10. Qd2 Nc6 11. Nde2 b5
+12. O-O-O Ng4 13. Rdf1 Qa5 14. h3 Nf6 15. Kb1 b4 16. Nd1 Qc7
+17. Ne3 a5 18. f4 a4 19. e5 dxe5 20. fxe5 Nxe5 21. Bxa8 Rxa8
+22. Rf4 axb3 23. axb3 Qa7 24. Nd4 Nh5 25. Nd5 Bc6 26. Nxc6
+Qa2+ 27. Kc1 Qa1+ 28. Bxa1 Rxa1+ 29. Kb2 Nc4# 0-1

main.cpp

@@ -1,4 +1,7 @@
+#ifdef _WIN32
 #include <windows.h>
+#endif
+#include <fstream>
 #include "Player/Player.hpp"
 #include "ChessPieces/Knight.hpp"
 #include "ChessPieces/Bishop.hpp"
@@ -13,7 +16,9 @@
 #include "Chessboard/ChessboardVisualizerGraphic.hpp"
 
 int main(int argc, char* argv[]) {
+    #ifdef _WIN32
     SetConsoleOutputCP(CP_UTF8);
+    #endif
 
     std::cout << "Spieler A: ";
     std::string namePlayerA;
@@ -69,13 +74,28 @@ int main(int argc, char* argv[]) {
 
     //ChessboardVisualizerText* visualizer = new ChessboardVisualizerText();
     ChessboardVisualizerGraphic* visualizer = new ChessboardVisualizerGraphic();
+    visualizer->Draw(&chessboard);
 
-    while (chessboard.IsCheckmate() == false) {
+    // Import chessboard from PGN file.
-      visualizer->Draw(&chessboard);
+    // https://www.chessgames.com/perl/chessgame?gid=1799484
+    // 1588906 - Checkmate
+    // 1482551 - Checkmate
+    // 1348060 - Checkmate
+    // 1799484 - Checkmate
+    // 1284086 - Stalemate
+    // 1258478 - Stalemate
+    // 1229276 - En Passant (black fxg3)
+    // 1775611 - En Passant (white axb6)
+    // 1427255 - En Passant (white bxc6+ and dxe6)
+    chessboard.ImportFilePGN("./chessgames/1258478.pgn");
+    visualizer->Draw(&chessboard);
+
+    while (chessboard.IsCheckmate() == false && chessboard.IsStalemate() == false) {
       std::string move;
       std::cout << "Move [" << ((chessboard.GetCurrentPlayer()->GetColor() == ChessPieceColor::White) ? "White" : "Black") << "] : ";
       std::cin >> move;
       chessboard.MoveChessPiece(move);
+      visualizer->Draw(&chessboard);
     }
 
     std::cout << "Game is over! - " << chessboard.GetOpponentPlayer()->GetName() << " has won the game!" << std::endl;

makefile

@@ -0,0 +1,10 @@
+all:
+	g++ -std=c++17 -o chess main.cpp ChessPieces/*.cpp Chessboard/*.cpp Player/*.cpp
+
+run:
+	./chess
+
+clean:
+	rm -f main.exe
+	rm -f chess.exe
+	rm -f chess

run.ps1

@@ -0,0 +1,2 @@
+& "g++" -std=c++17 -o chess main.cpp ChessPieces/*.cpp Chessboard/*.cpp Player/*.cpp
+./chess.exe