Darstellung der Menüs größten Teils umgesetzt; Navigation noch sehr buggy; Einige Features muessen noch umgesetzt werden (siehe README)

Chessboard.cpp

@@ -111,16 +111,6 @@ void Chessboard::draw (const std::vector<std::vector<char>>& chessboard) {
     std::cout << std::endl;
 }
 
-// ToDo:
-// Methode um mögliche Züge anzuzeigen
-// Rochade
-// Mate
-// Schachmate
-// En Passond
-// Restlichen moves
-// Angabe mit Menü Optionen als Zahlen
-// Figuren wählen mit Schachnotation
-
 void Chessboard::init() {
     Chessboard::initPieces();
 }
@@ -204,9 +194,6 @@ char Chessboard::getCorrectPiece(char pieceIdentifier) {
 
 //
 void Chessboard::move(std::string move) {
-    // ToDo:
-    // add move to history queue
-
     std::vector<std::string> splitMove;
 
     if (move.find('#') != std::string::npos) {

Chessboard.h

@@ -111,16 +111,6 @@ class Chessboard {
 
     void draw (const std::vector<std::vector<char>>& chessboard);
 
-    // ToDo:
-    // Methode um mögliche Züge anzuzeigen
-    // Rochade
-    // Mate
-    // Schachmate
-    // En Passond
-    // Restlichen moves
-    // Angabe mit Menü Optionen als Zahlen
-    // Figuren wählen mit Schachnotation
-
     void init();
 
     void initPieces();

Chessboard/ChessboardVisualizer.cpp

@@ -1 +1 @@
-#include "../Chessboard/ChessboardVisualizer.hpp"
+//#include "../Chessboard/ChessboardVisualizer.hpp"

Chessboard/ChessboardVisualizer.hpp

@@ -1,4 +1,4 @@
-#ifndef ChessboardVisualizer_H
+/*#ifndef ChessboardVisualizer_H
 #define ChessboardVisualizer_H
 
 #include "../ChessPieces/ChessPiece.hpp"
@@ -10,4 +10,4 @@ class ChessboardVisualizer {
     virtual void Draw(Chessboard* chessboard) = 0;
 };
 
-#endif
+#endif*/

Chessboard/ChessboardVisualizerGraphic.cpp

@@ -1,7 +1,9 @@
 #include "../Chessboard/ChessboardVisualizerGraphic.hpp"
 #include "../ChessPieces/ChessPiecePosition.hpp"
+#include "../Visualizer/HistorieVisualizer.hpp"
+#include "../Visualizer/BaseVisualizer.hpp"
 
-void ChessboardVisualizerGraphic::SetConsoleColor(Colors foreground, Colors background) {
+/*void ChessboardVisualizerGraphic::SetConsoleColor(Colors foreground, Colors background) {
   const std::string SEQ_FOREGROUND = "\x1b[3";
   const std::string SEQ_FOREGROUND_LIGHT = "\x1b[9";
   const std::string SEQ_BACKGROUND = "\x1b[4";
@@ -64,11 +66,7 @@ void ChessboardVisualizerGraphic::SetConsoleColor(Colors foreground, Colors back
   }
 }
 
-void ChessboardVisualizerGraphic::GenerateChessboard(Chessboard* chessboard) {
-  ClearTerminal();
-
-  GeneratePlayers(chessboard);
-
+void ChessboardVisualizerGraphic::temp(Chessboard* chessboard) {
   for (int rank = 8; rank >= 1; rank--) {
     if (rank == 8) GenerateTopOrBottomBorder(true);
 
@@ -94,7 +92,37 @@ void ChessboardVisualizerGraphic::GenerateChessboard(Chessboard* chessboard) {
     }
     if (rank == 1) GenerateTopOrBottomBorder(false);
   }
-  this->SetConsoleColor(DEFAULT, DEFAULT);
+}
+
+void ChessboardVisualizerGraphic::AddMenusToChessboard() {
+
+}
+
+void ChessboardVisualizerGraphic::GenerateChessboard(Chessboard* chessboard) {
+  ClearTerminal();
+
+  board.clear();
+
+  GeneratePlayers(chessboard);
+
+  temp(chessboard);
+
+  AddMenusToChessboard();
+
+  /*HistorieVisualizer history = HistorieVisualizer(15, 3, "Me", "Me");
+
+  std::vector<std::vector<std::string>> historyDisplayVector = history.GetDisplayVector();
+  std::vector<std::vector<std::string>> currentBoard = board;
+
+  for (size_t i = 0; i < historyDisplayVector.size(); i++) {
+    for (size_t j = 0; j < historyDisplayVector[i].size(); j++) {
+      board[i].push_back("         " + historyDisplayVector[i][j]);
+    }
+  }*/
+
+
+
+  /*this->SetConsoleColor(DEFAULT, DEFAULT);
   DrawFromVector();
 }
 
@@ -198,12 +226,6 @@ void ChessboardVisualizerGraphic::DrawFiles() {
 }
 
 std::string ChessboardVisualizerGraphic::GenerateBoardField(Chessboard* chessboard, char file, int rank, int height) {
-   if (file % 2 == (rank % 2)) {
-    this->SetConsoleColor(BLACK, WHITE);
-  } else {
-    this->SetConsoleColor(WHITE, BLACK);
-  }
-
   if (height == 1) {
     ChessPiecePosition* position = new ChessPiecePosition(file, rank);
 
@@ -240,7 +262,8 @@ void ChessboardVisualizerGraphic::DrawBoardField(Chessboard* chessboard, char fi
 }
 
 void ChessboardVisualizerGraphic::ClearTerminal() {
-  std::cout << "\033[2J"; // clear the console
+  //std::cout << "\033[2J"; // clear the console
+  system("cls");
 }
 
 void ChessboardVisualizerGraphic::GeneratePlayers(Chessboard* chessboard) {
@@ -263,6 +286,7 @@ void ChessboardVisualizerGraphic::AddRowToBoard(const std::vector<std::string>&
 // board[2] bis board[25] Feld des Schachbretts
 // in vectoren von 2 bis 25 index von 2 bis 9
 void ChessboardVisualizerGraphic::DrawFromVector() {
+  size_t lengthOfBoard = BaseVisualizer::GetSumAllCharsFromVector(board[1]);
   for (int row = 0; row < board.size(); ++row) {
     for (int column = 0; column < board[row].size(); ++column) {
       if (row >= 2 && row <= 25 && column >= 2 && column <= 9) {
@@ -283,10 +307,11 @@ void ChessboardVisualizerGraphic::DrawFromVector() {
           }
         }
       }
-      std::cout << board[row][column];
+      //std::cout << std::setw(lengthOfBoard) << board[row][column];
+
       this->SetConsoleColor(DEFAULT, DEFAULT);
     }
     this->SetConsoleColor(DEFAULT, DEFAULT);
     std::cout << std::endl;
   }
-}
+}*/

Chessboard/ChessboardVisualizerGraphic.hpp

@@ -1,17 +1,17 @@
-#ifndef ChessboardVisualizerGraphic_H
+/*#ifndef ChessboardVisualizerGraphic_H
 #define ChessboardVisualizerGraphic_H
 
 #include <string>
 #include <vector>
-#include "../Chessboard/ChessboardVisualizer.hpp"
+#include "../Chessboard/ChessboardVisualizer.hpp"*/
 
-enum Colors {
+/*enum Colors {
   BLACK = 0, RED = 1, GREEN = 2, YELLOW = 3, BLUE = 4, MAGENTA = 5, CYAN = 6, WHITE = 7,
   LIGHT_BLACK = 10, LIGHT_RED = 11, LIGHT_GREEN = 12, LIGHT_YELLOW = 13, LIGHT_BLUE = 14,
   LIGHT_MAGENTA = 15, LIGHT_CYAN = 16, LIGHT_WHITE = 17, DEFAULT = 9
-};
+};*/
 
-class ChessboardVisualizerGraphic : public ChessboardVisualizer {
+/*class ChessboardVisualizerGraphic : public ChessboardVisualizer {
   protected:
     inline static const std::string TOP_LEFT_CORNER = "\u2554";
     inline static const std::string TOP_RIGHT_CORNER = "\u2557";
@@ -31,8 +31,10 @@ class ChessboardVisualizerGraphic : public ChessboardVisualizer {
     void DrawBoardField(Chessboard* chessboard, char file, int rank, int height);
     void DrawFiles();
     void GenerateFiles();
-    void SetConsoleColor(Colors foreground, Colors background);
+    //void SetConsoleColor(Colors foreground, Colors background);
     void SetColorsForField();
+    void temp(Chessboard* chessboard);
+    void AddMenusToChessboard();
 
   public:
     ChessboardVisualizerGraphic() = default;
@@ -43,3 +45,4 @@ class ChessboardVisualizerGraphic : public ChessboardVisualizer {
 };
 
 #endif
+*/

Chessboard/ChessboardVisualizerText.cpp

@@ -1,7 +1,7 @@
 #include "../Chessboard/ChessboardVisualizerText.hpp"
 #include "../ChessPieces/ChessPiecePosition.hpp"
 
-void ChessboardVisualizerText::Draw(Chessboard* chessboard) {
+/*void ChessboardVisualizerText::Draw(Chessboard* chessboard) {
   std::cout << "\033[2J"; // clear the console
 
   std::cout << std::endl;
@@ -89,3 +89,4 @@ void ChessboardVisualizerText::Draw(Chessboard* chessboard) {
   }
   std::cout << std::endl;
 }
+*/

Chessboard/ChessboardVisualizerText.hpp

@@ -1,4 +1,4 @@
-#ifndef ChessboardVisualizerText_H
+/*#ifndef ChessboardVisualizerText_H
 #define ChessboardVisualizerText_H
 
 #include "../Chessboard/ChessboardVisualizer.hpp"
@@ -13,3 +13,4 @@ class ChessboardVisualizerText : public ChessboardVisualizer {
 };
 
 #endif
+*/

Program/Display.cpp

@@ -1 +0,0 @@
-#include "Display.h"

Program/Display.hpp

@@ -1,41 +0,0 @@
-//
-// Created by hamac on 10.01.2025.
-//
-
-#ifndef DISPLAY_H
-#define DISPLAY_H
-
-class Display {
-  public:
-    inline static std::vector<std::vector<std::string>> startMenu = {};
-    inline static std::vector<std::vector<std::string>> asciiArtTurboSchach = {
-        {"████████╗", "██╗░░░██╗", "██████╗░", "██████╗░", "░█████╗░", "░██████╗░", "█████╗░", "██╗░░██╗", "░█████╗░", "░█████╗░", "██╗░░██╗"},
-        {"╚══██╔══╝", "██║░░░██║", "██╔══██╗", "██╔══██╗", "██╔══██╗", "██╔════╝", "██╔══██╗", "██║░░██║", "██╔══██╗", "██╔══██╗", "██║░░██║"},
-        {"░░░██║░░░", "██║░░░██║", "██████╔╝", "██████╦╝", "██║░░██║", "╚█████╗░", "██║░░╚═╝", "███████║", "███████║", "██║░░╚═╝", "███████║"},
-        {"░░░██║░░░", "██║░░░██║", "██╔══██╗", "██╔══██╗", "██║░░██║", "░╚═══██╗", "██║░░██╗", "██╔══██║", "██╔══██║", "██║░░██╗", "██╔══██║"},
-        {"░░░██║░░░", "╚██████╔╝", "██║░░██║", "██████╦╝", "╚█████╔╝", "██████╔╝", "╚█████╔╝", "██║░░██║", "██║░░██║", "╚█████╔╝", "██║░░██║"},
-        {"░░░╚═╝░░░", "░╚═════╝░", "╚═╝░░╚═╝", "╚═════╝░", "░╚════╝░", "╚═════╝░", "░╚════╝░", "╚═╝░░╚═╝", "╚═╝░░╚═╝", "░╚════╝░", "╚═╝░░╚═╝"}
-    };
-
-    inline static std::vector<std::vector<std::string>> asciiArtMenu = {
-        { "▒█▀▄▀█", "█▀▀", "█▀▀▄", "█░░█" },
-		{ "▒█▒█▒█", "█▀▀", "█░░█", "█░░█" },
-		{ "▒█░░▒█", "▀▀▀", "▀░░▀", "░▀▀▀" }
-    };
-
-    inline static const std::string TOP_LEFT_CORNER = "\u2554";
-    inline static const std::string TOP_RIGHT_CORNER = "\u2557";
-    inline static const std::string HORIZONTAL_LINE = "\u2550";
-    inline static const std::string VERTICAL_LINE = "\u2551";
-    inline static const std::string BOTTOM_LEFT_CORNER = "\u255A";
-    inline static const std::string BOTTOM_RIGHT_CORNER = "\u255D";
-
-    inline static const std::string TOP_LEFT_CORNER_SINGLE = "\u250C";
-    inline static const std::string TOP_RIGHT_CORNER_SINGLE = "\u2510";
-    inline static const std::string HORIZONTAL_LINE_SINGLE = "\u2500";
-    inline static const std::string VERTICAL_LINE_SINGLE = "\u2502";
-    inline static const std::string BOTTOM_LEFT_CORNER_SINGLE = "\u2514";
-    inline static const std::string BOTTOM_RIGHT_CORNER_SINGLE = "\u2518";
-};
-
-#endif //DISPLAY_H

README.md

@@ -92,17 +92,26 @@
 
 ## ToDo
 - Speicherfunktion
+- ToDos abarbeiten
+- Anleitung schreiben
+- Befehlen während des Spiel implementieren
+- Bewegen funktioniert nicht -> Fixen!!!!
+- Historie -> Spielzüge speichern und anzeigen
+- Meldung für falschen Zug (Fehlermeldungen beim Spielen)
+- Nach Beenden nicht Pfad in Anzeige stehen lassen
+- Dark Mode
+
+## Erledigt
 - Schachnotation (Lange)
 - Menü (ASCII Art of TurboSchach)
   - Startmenü
   - Spielmenü mit Historie, Kommand
   - Plattformunabhängiges CMD clearing vor dem Zeichnen
 - Spezialbewegung (Rochade, Umwandlung, En passant)
-- Dark Mode
 
 ## Build
 ```
-g++ -o chess.exe main.cpp ChessPieces/*.cpp Chessboard/*.cpp Player/*.cpp
+g++ -o chess.exe main.cpp ChessPieces/*.cpp Chessboard/*.cpp Player/*.cpp Visualizer/*.cpp
 ```
 
 ## Voraussetzungen

Visualizer/BaseVisualizer.cpp

@@ -0,0 +1,259 @@
+#include "BaseVisualizer.hpp"
+
+void BaseVisualizer::ClearTerminal() {
+    //std::cout << "\033[2J";
+    system("cls");
+}
+
+std::vector<std::vector<std::string>>* BaseVisualizer::GetDisplayVector() {
+    return &display_vector;
+}
+
+size_t BaseVisualizer::CountVisibleCharacters(const std::string& str) {
+    size_t count = 0;
+    size_t i = 0;
+
+    while (i < str.size()) {
+        if (str[i] == '\x1B' && i + 1 < str.size() && str[i + 1] == '[') {
+            // ANSI-Escape-Sequenz erkennen und überspringen
+            i += 2; // Überspringe '\x1B['
+            while (i < str.size() && !std::isalpha(str[i])) {
+                ++i; // Fortsetzung der Sequenz überspringen
+            }
+            if (i < str.size() && std::isalpha(str[i])) {
+                ++i; // Buchstaben am Ende der Sequenz überspringen
+            }
+        } else {
+            // UTF-8 Startbytes zählen (kein Fortsetzungsbyte)
+            if ((str[i] & 0b11000000) != 0b10000000) {
+                ++count;
+            }
+            ++i;
+        }
+    }
+
+    return count;
+}
+
+size_t BaseVisualizer::GetSumAllCharsFromVector(const std::vector<std::string>& vec) {
+    size_t sum = 0;
+    for (const std::string& str : vec) {
+        sum += CountVisibleCharacters(str);
+    }
+    return sum;
+}
+
+void BaseVisualizer::GenerateEmptyLine(const int lengthOfMenu, const bool single) {
+    std::string result = "";
+    for (int i = 0; i < lengthOfMenu; ++i) {
+        if (i == 0) {
+            result += ((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE);
+        } else if (i == lengthOfMenu-1) {
+            result += ((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE);
+        } else {
+            result += " ";
+        }
+    }
+    display_vector.push_back({result});
+}
+
+// ToDo: Auf Max länge bringen
+void BaseVisualizer::GenerateBoxMenuLine(const size_t length, const std::string& str, const bool single, const size_t padding) {
+    std::string result = ((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE) + std::string(padding, ' ') + str;
+    while (CountVisibleCharacters(result) < length-1) {
+        result += " ";
+    }
+    display_vector.push_back({result.append(((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE))});
+}
+
+void BaseVisualizer::GenerateCenteredString(const size_t widthOfMenu, const std::string& str, const bool single) {
+    std::string result = (single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE;
+
+    float newLength = widthOfMenu - CountVisibleCharacters(str) - 2;
+
+    int firstHalfLength = std::floor(newLength / 2);
+    int secondHalfLength = std::ceil(newLength / 2);
+
+    for (int i = 0; i < firstHalfLength; ++i) {
+        result += " ";
+    }
+
+    result += str;
+
+    for (int i = 0; i < secondHalfLength; ++i) {
+        result += " ";
+    }
+
+    display_vector.push_back({result+ ((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE)});
+}
+
+void BaseVisualizer::DisplayElement() {
+  int temp;
+    for (const auto& row : display_vector) {
+        for (const auto& cell : row) {
+            std::cout << cell;
+        }
+        std::cout << std::endl;
+    }
+    std::cout << "\x1B[u";
+    //std::cout << "Select option" << std::endl;
+    std::cin >> temp;
+}
+
+size_t BaseVisualizer::CalculateMaxMenuWidth(const size_t longestStringLength, const size_t padding) {
+  return longestStringLength + 2*padding + 2;
+}
+
+void BaseVisualizer::GenerateTopBottomBorder(const size_t totalLength, const bool top, const bool single) {
+    std::string result = (top) ? ((single) ? BaseVisualizer::TOP_LEFT_CORNER_SINGLE : BaseVisualizer::TOP_LEFT_CORNER) : ((single) ? BaseVisualizer::BOTTOM_LEFT_CORNER_SINGLE : BaseVisualizer::BOTTOM_LEFT_CORNER);
+    for (size_t i = 0; i < totalLength-2; ++i) {
+        result += (single) ? BaseVisualizer::HORIZONTAL_LINE_SINGLE : BaseVisualizer::HORIZONTAL_LINE;
+    }
+    display_vector.push_back({result + ((top) ? ((single) ? BaseVisualizer::TOP_RIGHT_CORNER_SINGLE : BaseVisualizer::TOP_RIGHT_CORNER) : ((single) ? BaseVisualizer::BOTTOM_RIGHT_CORNER_SINGLE : BaseVisualizer::BOTTOM_RIGHT_CORNER))});
+}
+
+void BaseVisualizer::AddEmptyLines(const size_t lines, const size_t length, const bool sinlge) {
+  for (size_t i = 0; i < lines; ++i) {
+    BaseVisualizer::GenerateEmptyLine(length, sinlge);
+  }
+}
+
+void BaseVisualizer::GenerateTableTopBottom(const size_t totalLength, const bool top, const bool single) {
+    int firstHalfLength = std::floor(totalLength / 2);
+
+    std::string result = (top) ? ((single) ? BaseVisualizer::TOP_LEFT_CORNER_SINGLE : BaseVisualizer::TOP_LEFT_CORNER) : ((single) ? BaseVisualizer::BOTTOM_LEFT_CORNER_SINGLE : BaseVisualizer::BOTTOM_LEFT_CORNER);
+
+    for (size_t i = 0; i < firstHalfLength-1; ++i) {
+        result += (single) ? BaseVisualizer::HORIZONTAL_LINE_SINGLE : BaseVisualizer::HORIZONTAL_LINE;
+    }
+
+    result += (top) ? ((single) ? BaseVisualizer::TOP_CROSS_SINGLE : BaseVisualizer::TOP_CROSS) : ((single) ? BaseVisualizer::BOTTOM_CROSS_SINGLE : BaseVisualizer::BOTTOM_CROSS);
+
+    for (size_t i = 0; i < firstHalfLength-1; ++i) {
+        result += (single) ? BaseVisualizer::HORIZONTAL_LINE_SINGLE : BaseVisualizer::HORIZONTAL_LINE;
+    }
+
+    display_vector.push_back({result + ((top) ? ((single) ? BaseVisualizer::TOP_RIGHT_CORNER_SINGLE : BaseVisualizer::TOP_RIGHT_CORNER) : ((single) ? BaseVisualizer::BOTTOM_RIGHT_CORNER_SINGLE : BaseVisualizer::BOTTOM_RIGHT_CORNER))});
+}
+
+void BaseVisualizer::GenerateTableLine(const float length, const std::vector<std::string>& str, const bool single) {
+    int firstHalfLength = std::floor(length / 2);
+    std::string result = ((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE);
+    std::string temp;
+
+    for (size_t i = 0; i < 2; ++i) {
+         temp += "  " + str[i];
+
+        while (CountVisibleCharacters(temp) < firstHalfLength-1) {
+            temp += " ";
+        }
+        temp += ((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE);
+        result += temp;
+        temp = "";
+    }
+    display_vector.push_back({result});
+}
+
+void BaseVisualizer::GenerateTableSeperator(const float length, const bool single) {
+    int firstHalfLength = std::floor(length / 2);
+    std::string result = ((single) ? BaseVisualizer::RIGHT_CROSS_SINGLE : BaseVisualizer::RIGHT_CROSS);
+    std::string temp;
+
+    for (size_t i = 0; i < 2; ++i) {
+        while (CountVisibleCharacters(temp) < firstHalfLength-1) {
+            temp += ((single) ? BaseVisualizer::HORIZONTAL_LINE_SINGLE : BaseVisualizer::HORIZONTAL_LINE);
+        }
+        temp += (i != 1) ? ((single) ? BaseVisualizer::CROSS_SINGLE : BaseVisualizer::CROSS) : "";
+        result += temp;
+        temp = "";
+    }
+    result += ((single) ? BaseVisualizer::LEFT_CROSS_SINGLE : BaseVisualizer::LEFT_CROSS);
+
+    display_vector.push_back({result});
+}
+
+void BaseVisualizer::GenerateBoxSeperator(const float length, const bool single) {
+    std::string result = ((single) ? BaseVisualizer::RIGHT_CROSS_SINGLE : BaseVisualizer::RIGHT_CROSS);
+
+    while (CountVisibleCharacters(result) < length-1) {
+        result += ((single) ? BaseVisualizer::HORIZONTAL_LINE_SINGLE : BaseVisualizer::HORIZONTAL_LINE);
+    }
+
+    result += ((single) ? BaseVisualizer::LEFT_CROSS_SINGLE : BaseVisualizer::LEFT_CROSS);
+
+    display_vector.push_back({result});
+}
+
+void BaseVisualizer::SetConsoleColor(Colors foreground, Colors background) {
+  const std::string SEQ_FOREGROUND = "\x1b[3";
+  const std::string SEQ_FOREGROUND_LIGHT = "\x1b[9";
+  const std::string SEQ_BACKGROUND = "\x1b[4";
+  const std::string SEQ_BACKGROUND_LIGHT = "\x1b[10";
+
+  // set foreground color
+  switch (foreground) {
+    case BLACK:
+    case RED:
+    case GREEN:
+    case YELLOW:
+    case BLUE:
+    case MAGENTA:
+    case CYAN:
+    case WHITE:
+      std::cout << SEQ_FOREGROUND << foreground << "m";
+      break;
+    case LIGHT_BLACK:
+    case LIGHT_RED:
+    case LIGHT_GREEN:
+    case LIGHT_YELLOW:
+    case LIGHT_BLUE:
+    case LIGHT_MAGENTA:
+    case LIGHT_CYAN:
+    case LIGHT_WHITE:
+      std::cout << SEQ_FOREGROUND_LIGHT << foreground << "m";
+      break;
+    case DEFAULT:
+    default:
+      std::cout << SEQ_FOREGROUND << foreground << "m";
+      break;
+  }
+
+  // set background color
+  switch (background) {
+    case BLACK:
+    case RED:
+    case GREEN:
+    case YELLOW:
+    case BLUE:
+    case MAGENTA:
+    case CYAN:
+    case WHITE:
+      std::cout << SEQ_BACKGROUND << background << "m";
+      break;
+    case LIGHT_BLACK:
+    case LIGHT_RED:
+    case LIGHT_GREEN:
+    case LIGHT_YELLOW:
+    case LIGHT_BLUE:
+    case LIGHT_MAGENTA:
+    case LIGHT_CYAN:
+    case LIGHT_WHITE:
+      std::cout << SEQ_BACKGROUND_LIGHT << background << "m";
+      break;
+    case DEFAULT:
+    default:
+      std::cout << SEQ_BACKGROUND << background << "m";
+      break;
+  }
+}
+
+size_t BaseVisualizer::FindMaxLength(const std::vector<std::string> vec) {
+    size_t max = 0;
+    size_t currentLength = 0;
+    for (const std::string& str : vec) {
+        currentLength = CountVisibleCharacters(str);
+        (currentLength > max) ? max = CountVisibleCharacters(str) : max;
+    }
+    return max;
+}
+

Visualizer/BaseVisualizer.hpp

@@ -0,0 +1,99 @@
+#ifndef BASEVISUALIZER_H
+#define BASEVISUALIZER_H
+
+#include <string>
+#include <vector>
+#include <cmath>
+#include <iostream>
+
+enum Colors {
+  BLACK = 0, RED = 1, GREEN = 2, YELLOW = 3, BLUE = 4, MAGENTA = 5, CYAN = 6, WHITE = 7,
+  LIGHT_BLACK = 10, LIGHT_RED = 11, LIGHT_GREEN = 12, LIGHT_YELLOW = 13, LIGHT_BLUE = 14,
+  LIGHT_MAGENTA = 15, LIGHT_CYAN = 16, LIGHT_WHITE = 17, DEFAULT = 9
+};
+
+class BaseVisualizer {
+  protected:
+    inline static const std::string TOP_LEFT_CORNER = "\u2554";
+    inline static const std::string TOP_RIGHT_CORNER = "\u2557";
+    inline static const std::string HORIZONTAL_LINE = "\u2550";
+    inline static const std::string VERTICAL_LINE = "\u2551";
+    inline static const std::string BOTTOM_LEFT_CORNER = "\u255A";
+    inline static const std::string BOTTOM_RIGHT_CORNER = "\u255D";
+    inline static const std::string RIGHT_CROSS = "\u2560";
+    inline static const std::string LEFT_CROSS = "\u2563";
+    inline static const std::string CROSS = "\u256C";
+    inline static const std::string TOP_CROSS = "\u2566";
+    inline static const std::string BOTTOM_CROSS = "\u2569";
+
+    inline static const std::string TOP_LEFT_CORNER_SINGLE = "\u250C";
+    inline static const std::string TOP_RIGHT_CORNER_SINGLE = "\u2510";
+    inline static const std::string HORIZONTAL_LINE_SINGLE = "\u2500";
+    inline static const std::string VERTICAL_LINE_SINGLE = "\u2502";
+    inline static const std::string BOTTOM_LEFT_CORNER_SINGLE = "\u2514";
+    inline static const std::string BOTTOM_RIGHT_CORNER_SINGLE = "\u2518";
+    inline static const std::string RIGHT_CROSS_SINGLE  = "\u251C";
+    inline static const std::string LEFT_CROSS_SINGLE  = "\u2524";
+    inline static const std::string CROSS_SINGLE  = "\u253C";
+    inline static const std::string TOP_CROSS_SINGLE  = "\u252C";
+    inline static const std::string BOTTOM_CROSS_SINGLE  = "\u2534";
+
+    const size_t MAX_MENU_WIDTH;
+    const size_t PADDING;
+
+    std::vector<std::vector<std::string>> display_vector;
+
+    void GenerateEmptyLine(const int lengthOfMenu, const bool single);
+    void GenerateBoxMenuLine(const size_t length, const std::string& str, const bool single, const size_t padding);
+    void GenerateCenteredString(const size_t widthOfMenu, const std::string& str, const bool single);
+    size_t CalculateMaxMenuWidth(const size_t longestStringLength, const size_t padding);
+    size_t FindMaxLength(const std::vector<std::string> vec);
+    void GenerateTopBottomBorder(const size_t totalLength, const bool top, const bool single);
+    void AddEmptyLines(const size_t lines, const size_t length, const bool sinlge);
+    void GenerateTableTopBottom(const size_t totalLength, const bool top, const bool single);
+    void GenerateTableLine(const float length, const std::vector<std::string>& str, const bool single);
+    void GenerateTableSeperator(const float length, const bool single);
+    void GenerateBoxSeperator(const float length, const bool single);
+    void SetConsoleColor(Colors foreground, Colors background);
+
+    static size_t GetSumAllCharsFromVector(const std::vector<std::string>& vec);
+    static size_t CountVisibleCharacters(const std::string& str);
+
+  private:
+    virtual void GenerateElement() = 0;
+
+  public:
+    virtual ~BaseVisualizer() = default;
+    static void ClearTerminal();
+    void DisplayElement();
+    std::vector<std::vector<std::string>>* GetDisplayVector();
+    BaseVisualizer(size_t longestStringLength, size_t padding) : MAX_MENU_WIDTH(BaseVisualizer::CalculateMaxMenuWidth(longestStringLength, padding)), PADDING(padding) {}
+};
+
+#endif //BASEVISUALIZER_H
+
+/**
+*
+ChessboardVisualizer.cpp
+HistorieVisualizer.cpp
+CommandVisualizer.cpp
+
+PlayVisualizer.cpp {
+	ChessboardVisualizer.display_vector
+
+
+	HistorieVisualizer.display_vector;
+
+	CommandVisualizer.display_vector;
+
+	st::cout << ChessboardVisualizer.display_vector[i] (isEmpty) ? << std:endl : << Padding <<  Menus.display_vector[i] << std:endl;
+
+}
+
+
+
+
+
+
+
+*/

Visualizer/ChessboardVisualizer.cpp

@@ -0,0 +1,166 @@
+#include "ChessboardVisualizer.hpp"
+
+size_t ChessboardVisualizer::GetMaxBoardWidth() {
+    std::string temp;
+
+    temp.append(3, ' ');
+
+    temp += BaseVisualizer::TOP_LEFT_CORNER;
+    for (int i = 0; i < 8; i++) {
+      for (int j = 0; j < 7; j++) {
+        temp += BaseVisualizer::HORIZONTAL_LINE;
+      }
+    }
+    temp += BaseVisualizer::TOP_RIGHT_CORNER;
+
+    return BaseVisualizer::CountVisibleCharacters(temp);
+}
+
+void ChessboardVisualizer::GenerateTopBottomBorder(bool top, bool single) {
+    std::string temp;
+
+    temp.append(3, ' '); // ToDo: Padding?
+
+    temp += (top)
+                ? ((single)
+                       ? BaseVisualizer::TOP_LEFT_CORNER_SINGLE
+                       : BaseVisualizer::TOP_LEFT_CORNER)
+                : ((single)
+                       ? BaseVisualizer::BOTTOM_LEFT_CORNER_SINGLE
+                       : BaseVisualizer::BOTTOM_LEFT_CORNER);
+    for (int i = 0; i < 8; i++) {
+        for (int j = 0; j < 7; j++) {
+            temp += (single) ? BaseVisualizer::HORIZONTAL_LINE_SINGLE : BaseVisualizer::HORIZONTAL_LINE;
+        }
+    }
+    display_vector.push_back({temp + ((top) ? ((single) ? BaseVisualizer::TOP_RIGHT_CORNER_SINGLE : BaseVisualizer::TOP_RIGHT_CORNER) : ((single) ? BaseVisualizer::BOTTOM_RIGHT_CORNER_SINGLE : BaseVisualizer::BOTTOM_RIGHT_CORNER))});
+}
+
+void ChessboardVisualizer::GenerateElement() {
+  BaseVisualizer::ClearTerminal();
+
+  GeneratePlayers();
+
+  GenerateChessboard();
+
+  //GenerateDisplayVector();
+}
+
+void ChessboardVisualizer::GeneratePlayers() {
+  std::string result;
+  result.append(3, ' ');
+  display_vector.push_back({result + CHESSBOARD->GetPlayer(ChessPieceColor::White)->GetName()
+                                           + " vs. " + CHESSBOARD->GetPlayer(ChessPieceColor::Black)->GetName()});
+}
+
+void ChessboardVisualizer::GenerateChessboard() {
+  std::vector<std::string> temp;
+  for (int rank = 8; rank >= 1; rank--) {
+    if (rank == 8) GenerateTopBottomBorder(true, true);
+    for (int heightOfField = 0; heightOfField < 3; heightOfField++) {
+      for (char file = 'A'; file <= 'H'; file++) {
+        if (file == 'A') {
+          temp.push_back((heightOfField == 1) ? " " + std::to_string(rank) + " " : std::string(3, ' '));
+          temp.push_back(BaseVisualizer::VERTICAL_LINE_SINGLE);
+        }
+
+        temp.push_back(GenerateBoardField(file, rank, heightOfField));
+
+        if (file == 'H') {
+          temp.push_back(BaseVisualizer::VERTICAL_LINE_SINGLE);
+        }
+      }
+      display_vector.push_back(temp);
+      temp.clear();
+    }
+    if (rank == 1) {
+      GenerateTopBottomBorder(false, true);
+      GenerateFiles();
+    }
+  }
+}
+
+std::string ChessboardVisualizer::GenerateBoardField(char file, int rank, int height) {
+  ChessPiecePosition* position = new ChessPiecePosition(file, rank);
+  if (height == 1 && !CHESSBOARD->IsEmptyField(position)) {
+  	ChessPiece* piece = CHESSBOARD->GetChessPiece(position);
+  	return std::string(3, ' ') + piece->GetUnicode() + std::string(3, ' ');
+  }
+  return std::string(7, ' ');
+}
+
+void ChessboardVisualizer::GenerateFiles() {
+  std::string temp;
+
+  for (char file = 'A'; file <= 'H'; file++) {
+    if (file == 'A') {
+      temp += (std::string(4, ' '));
+    }
+
+    temp += (std::string(3, ' ') + std::string(1, file) + std::string(3, ' '));
+
+    if (file == 'H') {
+      temp += " ";
+     }
+  }
+  display_vector.push_back({temp});
+}
+
+
+// board[2] bis board[25] Feld des Schachbretts
+// in vectoren von 2 bis 25 index von 2 bis 9
+void ChessboardVisualizer::DisplayElement() {
+  size_t size;
+  std::string temp;
+  for (int row = 0; row < display_vector.size(); ++row) {
+    for (int column = 0; column < display_vector[row].size(); ++column) {
+      if (row >= 2 && row <= 25 && column >= 2 && column <= 9) {
+        bool isSecondRowOfField = (row % 3 == 2);
+        bool isBlackWhite = (column % 2 == row % 2);
+
+        if ((row - 1) % 3 == 0) { // Change after 3 rows
+          if (isSecondRowOfField) {
+            this->SetConsoleColor(isBlackWhite ? WHITE : BLACK, isBlackWhite ? BLACK : WHITE);
+          } else {
+            this->SetConsoleColor(isBlackWhite ? BLACK : WHITE, isBlackWhite ? WHITE : BLACK);
+          }
+        } else {
+          if (isSecondRowOfField) {
+            this->SetConsoleColor(isBlackWhite ? BLACK : WHITE, isBlackWhite ? WHITE : BLACK);
+          } else {
+            this->SetConsoleColor(isBlackWhite ? WHITE : BLACK, isBlackWhite ? BLACK : WHITE);
+          }
+        }
+      }
+      std::cout << display_vector[row][column];
+      this->SetConsoleColor(DEFAULT, DEFAULT);
+    }
+    this->SetConsoleColor(DEFAULT, DEFAULT);
+
+    std::cout << std::endl;
+  }
+}
+
+/*void ChessboardVisualizer::GenerateDisplayVector() {
+  std::string temp;
+  size_t size;
+
+  for (auto& row : draw_vector) {
+    if (row.size() > 1) {
+      for (const auto& element : row) {
+        temp += element;
+      }
+      display_vector.push_back(FillStringToMaxLength(temp));
+      temp = "";
+    } else {
+      display_vector.push_back(FillStringToMaxLength(row[0]));
+    }
+  }
+}
+
+std::string ChessboardVisualizer::FillStringToMaxLength(std::string& str) {
+  size_t size = BaseVisualizer::CountVisibleCharacters(str);
+  return ((size == MAX_MENU_WIDTH)
+              ? str
+              : str.append(std::string(MAX_MENU_WIDTH - size, ' ')));
+}*/

Visualizer/ChessboardVisualizer.hpp

@@ -0,0 +1,32 @@
+#ifndef CHESSBOARDVISUALIZER_HPP
+#define CHESSBOARDVISUALIZER_HPP
+
+#include "BaseVisualizer.hpp"
+#include "../Chessboard/Chessboard.hpp"
+#include "../Chesspieces/Chesspiece.hpp"
+
+class ChessboardVisualizer : public BaseVisualizer {
+
+  private:
+    Chessboard* CHESSBOARD;
+    std::vector<std::vector<std::string>> draw_vector;
+
+    static size_t GetMaxBoardWidth();
+
+    void GenerateTopBottomBorder(bool top, bool single);
+    void GenerateElement() override;
+    void GeneratePlayers();
+    void GenerateChessboard();
+    void GenerateFiles();
+    std::string GenerateBoardField(char file, int rank, int height);
+    void GenerateDisplayVector();
+    std::string FillStringToMaxLength(std::string& str);
+
+  public:
+    ChessboardVisualizer(Chessboard* chessboard, size_t padding) : BaseVisualizer(ChessboardVisualizer::GetMaxBoardWidth(), padding), CHESSBOARD(chessboard) {
+    	ChessboardVisualizer::GenerateElement();
+    };
+    void DisplayElement();
+};
+
+#endif //CHESSBOARDVISUALIZER_HPP

Visualizer/CommandMenuVisualizer.cpp

@@ -0,0 +1,13 @@
+#include "CommandMenuVisualizer.hpp"
+
+void CommandMenuVisualizer::GenerateElement() {
+    BaseVisualizer::display_vector.push_back({"Commands"});
+    BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, true, true);
+    for (const auto& content : menuContent) {
+      BaseVisualizer::GenerateBoxMenuLine(MAX_MENU_WIDTH, content, true, PADDING);
+    }
+    BaseVisualizer::GenerateBoxSeperator(MAX_MENU_WIDTH, true);
+    std::string str_temp = ((CHESSBOARD->GetCurrentPlayer()->GetColor() == ChessPieceColor::White) ? "White" : "Black");
+    BaseVisualizer::GenerateBoxMenuLine(MAX_MENU_WIDTH, "Move [" + str_temp + "] : " + "\x1B[s", true, true);
+    BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, false, true);
+}

Visualizer/CommandMenuVisualizer.hpp

@@ -0,0 +1,30 @@
+#ifndef COMMANDMENUVISUALIZER_HPP
+#define COMMANDMENUVISUALIZER_HPP
+
+#include "BaseVisualizer.hpp"
+#include "../Chessboard/Chessboard.hpp"
+
+class CommandMenuVisualizer : public BaseVisualizer {
+  private:
+    inline static const std::vector<std::string> menuContent = {
+      "To execute command: $<command_no>",
+      "",
+      "1 - Instructions",
+      "2 - Save",
+      "3 - Exit",
+      "",
+      "8 - Resign",
+      "9 - Draw"
+    };
+
+    Chessboard* CHESSBOARD;
+
+    void GenerateElement() override;
+
+  public:
+    CommandMenuVisualizer(Chessboard* chessboard, size_t padding) : BaseVisualizer(CommandMenuVisualizer::FindMaxLength(menuContent), padding), CHESSBOARD(chessboard) {
+      CommandMenuVisualizer::GenerateElement();
+    }
+};
+
+#endif //COMMANDMENUVISUALIZER_HPP

Visualizer/HistorieVisualizer.cpp

@@ -0,0 +1,16 @@
+#include "HistorieVisualizer.hpp"
+
+void HistorieVisualizer::GenerateElement() {
+    BaseVisualizer::display_vector.push_back({"Historie"});
+    BaseVisualizer::GenerateTableTopBottom(MAX_MENU_WIDTH, true, true);
+
+    BaseVisualizer::GenerateTableLine(MAX_MENU_WIDTH, {HistorieVisualizer::PLAYER1, HistorieVisualizer::PLAYER2}, true);
+    BaseVisualizer::BaseVisualizer::GenerateTableSeperator(MAX_MENU_WIDTH, true);
+
+    // ToDo: History einlesen und anzeigen lassenF
+    for (size_t i = 0; i < 5; i++) {
+        BaseVisualizer::GenerateTableLine(MAX_MENU_WIDTH, {"", ""}, true);
+    }
+
+    BaseVisualizer::GenerateTableTopBottom(MAX_MENU_WIDTH, false, true);
+}

Visualizer/HistorieVisualizer.hpp

@@ -0,0 +1,28 @@
+#ifndef HISTORIEVISUALIZER_HPP
+#define HISTORIEVISUALIZER_HPP
+
+#include "BaseVisualizer.hpp"
+#include "../Chessboard/Chessboard.hpp"
+
+class HistorieVisualizer : public BaseVisualizer {
+    private:
+      const std::string PLAYER1;
+      const std::string PLAYER2;
+
+      std::vector<std::vector<std::string>> histories;
+      Chessboard* CHESSBOARD;
+
+      void GenerateElement() override;
+
+    public:
+      HistorieVisualizer(Chessboard* chessbord,const size_t menuWidth, const size_t padding) :
+        BaseVisualizer(menuWidth, padding), histories(5, std::vector<std::string>(2, "")),
+        CHESSBOARD(chessbord),
+        PLAYER1(chessbord->GetPlayer(ChessPieceColor::White)->GetName()),
+        PLAYER2(chessbord->GetPlayer(ChessPieceColor::Black)->GetName())
+      {
+        HistorieVisualizer::GenerateElement();
+      };
+};
+
+#endif //HISTORIEVISUALIZER_HPP

Visualizer/InstructionsVisualizer.cpp

@@ -0,0 +1,13 @@
+#include "InstructionsVisualizer.hpp"
+
+void InstructionsVisualizer::GenerateElement() {
+  BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, true, false);
+  BaseVisualizer::AddEmptyLines(5, MAX_MENU_WIDTH, false);
+  for (const auto& content : menuContent) {
+    BaseVisualizer::GenerateBoxMenuLine(MAX_MENU_WIDTH, content, false, PADDING);
+  }
+  BaseVisualizer::AddEmptyLines(2, MAX_MENU_WIDTH, false);
+  BaseVisualizer::GenerateBoxMenuLine(MAX_MENU_WIDTH, "Enter any key to return to menu: \x1B[s", false, PADDING);
+  BaseVisualizer::AddEmptyLines(5, MAX_MENU_WIDTH, false);
+  BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, false, false);
+}

Visualizer/InstructionsVisualizer.hpp

@@ -0,0 +1,19 @@
+#ifndef INSTRUCTIONSVISUALIZER_HPP
+#define INSTRUCTIONSVISUALIZER_HPP
+
+#include "BaseVisualizer.hpp"
+
+class InstructionsVisualizer : public BaseVisualizer {
+  private:
+    inline static const std::vector<std::string> menuContent = {
+        "Hier kommt noch eine Anleitung"
+    };
+    void GenerateElement() override;
+
+  public:
+    InstructionsVisualizer() : BaseVisualizer(60, 4) {
+        InstructionsVisualizer::GenerateElement();
+    };
+};
+
+#endif //INSTRUCTIONSVISUALIZER_HPP

Visualizer/PlayingViewVisualizer.cpp

@@ -0,0 +1,103 @@
+#include "PlayingViewVisualizer.hpp"
+#include "ChessboardVisualizer.hpp"
+#include "HistorieVisualizer.hpp"
+#include "CommandMenuVisualizer.hpp"
+
+void PlayingViewVisualizer::GenerateElement() {
+  position_vector.clear();
+  display_vector.clear();
+  ChessboardVisualizer chessboardVisualizer = ChessboardVisualizer(CHESSBOARD, 2);
+  HistorieVisualizer historieVisualizer = HistorieVisualizer(CHESSBOARD, 32, 2);
+  CommandMenuVisualizer cmdMenuVisualizer = CommandMenuVisualizer(CHESSBOARD, 2);
+
+  GeneratePositionVector(chessboardVisualizer.GetDisplayVector(), historieVisualizer.GetDisplayVector(), cmdMenuVisualizer.GetDisplayVector());
+
+  BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, true, false);
+  BaseVisualizer::GenerateEmptyLine(MAX_MENU_WIDTH, false);
+
+  std::vector<std::string> temp;
+
+  //((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE) + std::string(padding, ' ')
+
+  for (const auto& row : position_vector) {
+    display_vector.push_back(row);
+  }
+
+  BaseVisualizer::GenerateEmptyLine(MAX_MENU_WIDTH, false);
+  BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, false, false);
+  //size_t maxWidth = BaseVisualizer::FindMaxLength(chessboardVisualizer.display_vector);
+
+}
+
+void PlayingViewVisualizer::GeneratePositionVector(
+  std::vector<std::vector<std::string>>* chessboard_display_vector,
+  std::vector<std::vector<std::string>>* historie_display_vector,
+  std::vector<std::vector<std::string>>* command_menu_display_vector)
+{
+  for (size_t i = 0; i < chessboard_display_vector->size(); ++i) {
+    size_t test;
+    std::vector<std::string> temp;
+    temp.push_back({BaseVisualizer::VERTICAL_LINE + "   "});
+    if (i == 0) {
+      const std::string& first_element = chessboard_display_vector->at(i).at(0);
+      temp.push_back(first_element);
+      temp.push_back(std::string(62-BaseVisualizer::CountVisibleCharacters(first_element), ' '));
+    } else if (chessboard_display_vector->at(i).size() > 1 && i != 0) {
+      temp.insert(temp.end(), chessboard_display_vector->at(i).begin(), chessboard_display_vector->at(i).end());
+    } else {
+      temp.push_back(chessboard_display_vector->at(i).at(0));
+    }
+
+    if (i < historie_display_vector->size()) {
+      temp.push_back(std::string(DISTANCE_BETWEEN_ELEMENTS, ' '));
+      temp.push_back(historie_display_vector->at(i)[0]);
+    } else if (i-3-historie_display_vector->size() < command_menu_display_vector->size()) {
+      temp.push_back(std::string(DISTANCE_BETWEEN_ELEMENTS, ' '));
+      temp.push_back(command_menu_display_vector->at(i-3-historie_display_vector->size())[0]);
+    } else{
+      temp.push_back({"", ""});
+    }
+
+    BaseVisualizer::GetSumAllCharsFromVector(temp);
+    temp.push_back(std::string(MAX_MENU_WIDTH-BaseVisualizer::GetSumAllCharsFromVector(temp)-1, ' ') + BaseVisualizer::VERTICAL_LINE);
+
+    position_vector.push_back(temp);
+  }
+}
+
+void PlayingViewVisualizer::DisplayElement() {
+  PlayingViewVisualizer::GenerateElement();
+  size_t size;
+  std::string temp;
+  for (int row = 0; row < display_vector.size(); ++row) {
+    for (int column = 0; column < display_vector[row].size(); ++column) {
+      if (row >= 4 && row <= 27 && column >= 3 && column <= 10) {
+        bool isSecondRowOfField = ((row-1) % 3 == 2);
+        bool isBlackWhite = ((column-1) % 2 == (row-1) % 2);
+
+        if ((row - 1) % 3 == 0) { // Change after 3 rows
+          if (isSecondRowOfField) {
+            this->SetConsoleColor(isBlackWhite ? BLACK : WHITE, isBlackWhite ? WHITE : BLACK);
+          } else {
+            this->SetConsoleColor(isBlackWhite ? WHITE : BLACK, isBlackWhite ? BLACK : WHITE);
+          }
+        } else {
+          if (isSecondRowOfField) {
+            this->SetConsoleColor(isBlackWhite ? WHITE : BLACK, isBlackWhite ? BLACK : WHITE);
+          } else {
+            this->SetConsoleColor(isBlackWhite ? BLACK : WHITE, isBlackWhite ? WHITE : BLACK);
+          }
+        }
+      }
+      std::cout << display_vector[row][column];
+      this->SetConsoleColor(DEFAULT, DEFAULT);
+    }
+    this->SetConsoleColor(DEFAULT, DEFAULT);
+
+    std::cout << std::endl;
+  }
+}
+
+std::string PlayingViewVisualizer::GetMove() {
+  return move;
+}

Visualizer/PlayingViewVisualizer.hpp

@@ -0,0 +1,29 @@
+#ifndef PLAYINGVIEWVISUALIZER_HPP
+#define PLAYINGVIEWVISUALIZER_HPP
+
+#include "BaseVisualizer.hpp"
+#include "../Chessboard/Chessboard.hpp"
+
+class PlayingViewVisualizer : public BaseVisualizer {
+  private:
+    const size_t DISTANCE_BETWEEN_ELEMENTS;
+
+    Chessboard* CHESSBOARD;
+    std::string move;
+
+    std::vector<std::vector<std::string>> position_vector;
+
+    void GenerateElement();
+    void GeneratePositionVector(
+      std::vector<std::vector<std::string>>* chessboard_display_vector,
+      std::vector<std::vector<std::string>>* historie_display_vector,
+      std::vector<std::vector<std::string>>* command_menu_display_vector);
+
+  public:
+    PlayingViewVisualizer(Chessboard* chessboard, size_t padding, size_t distance) :
+      BaseVisualizer(110, padding), CHESSBOARD(chessboard), DISTANCE_BETWEEN_ELEMENTS(distance) {}
+    void DisplayElement();
+    std::string GetMove();
+};
+
+#endif //PLAYINGVIEWVISUALIZER_HPP

Visualizer/StartMenuVisualizer.cpp

@@ -0,0 +1,66 @@
+#include "StartMenuVisualizer.hpp"
+
+void StartMenuVisualizer::GenerateElement() {
+  BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, true, false);
+
+  BaseVisualizer::AddEmptyLines(2, MAX_MENU_WIDTH, false);
+
+  for (const auto& str : StartMenuVisualizer::ACSII_ART_TURBO_SCHACH) {
+    BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, str, false);
+  }
+
+  BaseVisualizer::AddEmptyLines(2, MAX_MENU_WIDTH, false);
+
+  BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, "Welcome to TurboSchach!", false);
+
+  BaseVisualizer::AddEmptyLines(2, MAX_MENU_WIDTH, false);
+
+  BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, "Please select one of the menu options:", false);
+  BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, "\x1B[s", false);
+
+  BaseVisualizer::AddEmptyLines(1, MAX_MENU_WIDTH, false);
+
+  // ToDo: Attribute zum direkten setzen des Types der Außenbegrenzung -> Allgemein in BaseVisualizer auch?
+  // ToDo: Überarbeiten -> Extra Methode um Menus im Menu zu generieren
+  BaseVisualizer::GenerateTopBottomBorder(24, true, true);
+  BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, BaseVisualizer::display_vector[BaseVisualizer::display_vector.size()-1][0], false);
+  BaseVisualizer::display_vector.erase(BaseVisualizer::display_vector.begin() + (BaseVisualizer::display_vector.size() - 2));
+
+
+  for (const auto& str : StartMenuVisualizer::MENU_OPTIONS) {
+    BaseVisualizer::GenerateBoxMenuLine(24, str, true, 1);
+    BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, BaseVisualizer::display_vector[BaseVisualizer::display_vector.size()-1][0], false);
+    BaseVisualizer::display_vector.erase(BaseVisualizer::display_vector.begin() + (BaseVisualizer::display_vector.size() - 2));
+
+  }
+
+  BaseVisualizer::GenerateTopBottomBorder(24, false, true);
+  BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, BaseVisualizer::display_vector[BaseVisualizer::display_vector.size()-1][0], false);
+  BaseVisualizer::display_vector.erase(BaseVisualizer::display_vector.begin() + (BaseVisualizer::display_vector.size() - 2));
+
+
+  BaseVisualizer::AddEmptyLines(2, MAX_MENU_WIDTH, false);
+
+  BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, false, false);
+}
+
+int StartMenuVisualizer::GetSelectedOption() {
+  return selectedOption;
+}
+
+void StartMenuVisualizer::SetSelectedOption(int optionSelect) {
+  selectedOption = selectedOption;
+};
+
+void StartMenuVisualizer::DisplayElement1() {
+  BaseVisualizer::ClearTerminal();
+  int temp;
+  for (const auto& row : display_vector) {
+    for (const auto& cell : row) {
+        std::cout << cell;
+    }
+    std::cout << std::endl;
+  }
+  std::cout << "\x1B[u";
+  std::cin >> selectedOption;
+}

Visualizer/StartMenuVisualizer.hpp

@@ -0,0 +1,39 @@
+#ifndef STARTMENUVISUALIZER_H
+#define STARTMENUVISUALIZER_H
+
+#include "BaseVisualizer.hpp"
+
+class StartMenuVisualizer : public BaseVisualizer {
+  private:
+    inline static const std::vector<std::string> ACSII_ART_TURBO_SCHACH = {
+      "████████╗██╗░░░██╗██████╗░██████╗░░█████╗░░██████╗░█████╗░██╗░░██╗░█████╗░░█████╗░██╗░░██╗",
+      "╚══██╔══╝██║░░░██║██╔══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗██║░░██║██╔══██╗██╔══██╗██║░░██║",
+      "░░░██║░░░██║░░░██║██████╔╝██████╦╝██║░░██║╚█████╗░██║░░╚═╝███████║███████║██║░░╚═╝███████║",
+      "░░░██║░░░██║░░░██║██╔══██╗██╔══██╗██║░░██║░╚═══██╗██║░░██╗██╔══██║██╔══██║██║░░██╗██╔══██║",
+      "░░░██║░░░╚██████╔╝██║░░██║██████╦╝╚█████╔╝██████╔╝╚█████╔╝██║░░██║██║░░██║╚█████╔╝██║░░██║",
+      "░░░╚═╝░░░░╚═════╝░╚═╝░░╚═╝╚═════╝░░╚════╝░╚═════╝░░╚════╝░╚═╝░░╚═╝╚═╝░░╚═╝░╚════╝░╚═╝░░╚═╝"
+    };
+
+    inline static const std::vector<std::string> MENU_OPTIONS = {
+      "1 - New Game",
+      "2 - Load Save",
+      "3 - Instructions",
+      "",
+      "0 - Exit"
+    };
+
+    int selectedOption = -1;
+
+    void GenerateElement() override;
+
+  public:
+    StartMenuVisualizer(size_t padding) : BaseVisualizer(BaseVisualizer::CountVisibleCharacters(StartMenuVisualizer::ACSII_ART_TURBO_SCHACH[0]), padding) {
+      StartMenuVisualizer::GenerateElement();
+    }
+    int GetSelectedOption();
+    void SetSelectedOption(int selectedOption);
+    void DisplayElement1();
+
+};
+
+#endif //STARTMENUVISUALIZER_H

main.cpp

@@ -1,188 +1,141 @@
 #include <windows.h>
-#include <memory>
 #include "Player/Player.hpp"
 #include "ChessPieces/ChessPiece.hpp"
 #include "Chessboard/Chessboard.hpp"
 #include "Chessboard/ChessboardVisualizerText.hpp"
 #include "Chessboard/ChessboardVisualizerGraphic.hpp"
-#include "Program/Display.hpp"
+#include "Visualizer/BaseVisualizer.hpp"
+#include "Visualizer/StartMenuVisualizer.hpp"
+#include "Visualizer/HistorieVisualizer.hpp"
+#include "Visualizer/ChessboardVisualizer.hpp"
+#include "Visualizer/CommandMenuVisualizer.hpp"
+#include "Visualizer/PlayingViewVisualizer.hpp"
+#include "Visualizer/InstructionsVisualizer.hpp"
 
 #include <iostream>
+#include <memory>
 #include <vector>
 #include <string>
 #include <locale>
 
-// Funktion zur Zählung von UTF-8-Zeichen
-size_t countVisibleCharacters(const std::string& str) {
-    size_t count = 0;
-    for (size_t i = 0; i < str.size(); ++i) {
-        // UTF-8 Startbytes zählen (kein Fortsetzungsbyte)
-        if ((str[i] & 0b11000000) != 0b10000000) {
-            ++count;
-        }
-    }
-    return count;
+void HandleThirdOption() {
+  BaseVisualizer::ClearTerminal();
+  InstructionsVisualizer instructions = InstructionsVisualizer();
+  instructions.DisplayElement();
+  std::cout << "\x1B[u";
+  std::cin;
 }
 
-int GetSumAllCharsFromVector(const std::vector<std::string>& vec) {
-  	int sum = 0;
-    for (const std::string& str : vec) {
-      sum += countVisibleCharacters(str);
-    }
-    return sum;
+void HandleCommandOptions(const std::string& command) {
+  if (command == "1") {
+    HandleThirdOption();
+  } else if (command == "2") {
+    // ToDo: Save implementieren
+  } else if (command == "3") {
+    // ToDo: Exit implementieren -> Möglichkeit noch zu speichern oder einfach speichern?
+  } else if (command == "8") {
+    // ToDo: Spiel beenden -> Gewinn an anderen gegeben
+  } else if (command == "9") {
+    // ToDo: Draw anbieten -> Anfrage mit Annahme/Ablehnen an anderen Spieler schicken
+  }
 }
 
-std::vector<std::string> GenerateEmptyLine(int lengthOfMenu) {
-  	std::vector<std::string> result;
-    std::string string = "";
-    for (int i = 0; i < lengthOfMenu; ++i) {
-      if (i == 0) {
-        result.push_back(Display::VERTICAL_LINE);
-      } else if (i == lengthOfMenu-1) {
-      	result.push_back(string + Display::VERTICAL_LINE);
+std::string ExtractAfterDollar(const std::string& userInput) {
+    // Überprüfen, ob der String mit '$' beginnt
+    if (!userInput.empty() && userInput[0] == '$') {
+        return userInput.substr(1); // Rückgabe des Teils nach '$'
+    }
+    return ""; // Leerer String, wenn kein '$' am Anfang
+}
+
+void HandleFirstOption() {
+  BaseVisualizer::ClearTerminal();
+  Player* playerA = new Player("Player 1");
+  Player* playerB = new Player("Player 2");
+
+  Chessboard chessboard = Chessboard();
+  chessboard.SetPlayers(playerA, playerB);
+
+  chessboard.InitializeStartBoard();
+
+  PlayingViewVisualizer playView = PlayingViewVisualizer(&chessboard, 4, 12);
+
+  while (chessboard.IsCheckmate() == false) {
+    std::string input;
+
+    playView.DisplayElement();
+
+    std::cout << "\x1B[u";
+    std::cin >> input;
+
+    std::string command = ExtractAfterDollar(input);
+
+    while (command != "3") {
+      if (command != "") {
+        HandleCommandOptions(command);
+        break;
       } else {
-        string += " ";
+        //ToDo: Valide Züge annehmen
+        chessboard.MoveChessPiece(input);
       }
+      // ToDo: Nicht valide Eingabe melden -> Unterscheidung was falsch?
     }
-    return result;
-}
-
-void GenerateCenteredString(int lengthOfMenu, std::string str) {
-  std::string result = Display::VERTICAL_LINE;
-
-  float newLength = lengthOfMenu - countVisibleCharacters(str) - 2;
-
-  int firstHalfLength = std::floor(newLength / 2);
-  int secondHalfLength = std::ceil(newLength / 2);
-
-  for (int i = 0; i < firstHalfLength; ++i) {
-    result += " ";
+    break;
   }
-
-  result += str;
-
-  for (int i = 0; i < secondHalfLength; ++i) {
-  	result += " ";
-  }
-
-  Display::startMenu.push_back(std::vector<std::string>{result + Display::VERTICAL_LINE});
-}
-
-std::string GenerateBoxMenuLine(int size, std::string str) {
-    std::string result = Display::VERTICAL_LINE_SINGLE + "   " + str;
-    while (countVisibleCharacters(result) < size) {
-      result += " ";
-    }
-   	return result + Display::VERTICAL_LINE_SINGLE;
+  std::cout << "Game is over! - " << chessboard.GetOpponentPlayer()->GetName() << " has won the game!" << std::endl;
 }
 
+void HandleSecondOption() {}
 
 int main() {
     SetConsoleOutputCP(CP_UTF8);
-	std::cout << "\033[2J";
 
+    BaseVisualizer::ClearTerminal();
 
-	int widthOfStartMenu = Display::asciiArtTurboSchach.size() + 4;
+    StartMenuVisualizer startMenu = StartMenuVisualizer(3);
+    int choice = -1;
 
-    std::vector<std::string> temp;
+    while (startMenu.GetSelectedOption() != 0) {
+      BaseVisualizer::ClearTerminal();
+      startMenu.DisplayElement1();
 
-    std::vector<std::string> topBorderHorizontals;
-    std::string string;
-
-    topBorderHorizontals.push_back(Display::TOP_LEFT_CORNER + Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE);
-  	for (const std::string& str : Display::asciiArtTurboSchach[0]) {
-    	for (int i = 0; i < countVisibleCharacters(str); ++i) {
-      		string += Display::HORIZONTAL_LINE;
-    	}
-    	topBorderHorizontals.push_back(string);
-    	string = "";
-  	}
-    topBorderHorizontals.push_back(Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE + Display::TOP_RIGHT_CORNER);
-
-    int lengthOfMenu = GetSumAllCharsFromVector(topBorderHorizontals);
-
-	Display::startMenu.push_back(topBorderHorizontals);
-    Display::startMenu.push_back(GenerateEmptyLine(lengthOfMenu));
-    Display::startMenu.push_back(GenerateEmptyLine(lengthOfMenu));
-
-    for (const auto& row : Display::asciiArtTurboSchach) {
-      temp.push_back(Display::VERTICAL_LINE + "    ");
-      for (const auto& column : row) {
-        temp.push_back(column);
+      if (startMenu.GetSelectedOption() == 1) {
+        HandleFirstOption();
+      } else if (startMenu.GetSelectedOption() == 2) {
+        HandleSecondOption();
+      } else if (startMenu.GetSelectedOption() == 3) {
+        HandleThirdOption();
       }
-      temp.push_back("    " + Display::VERTICAL_LINE);
-      Display::startMenu.push_back(temp);
-      temp.clear();
     }
 
-    Display::startMenu.push_back(GenerateEmptyLine(lengthOfMenu));
-    Display::startMenu.push_back(GenerateEmptyLine(lengthOfMenu));
-
-	GenerateCenteredString(lengthOfMenu, "Welcome to TurboSchach!");
-
-    temp.clear();
-
-    Display::startMenu.push_back(GenerateEmptyLine(lengthOfMenu));
-    Display::startMenu.push_back(GenerateEmptyLine(lengthOfMenu));
-
-    GenerateCenteredString(lengthOfMenu, "Please select one of the menu options:");
-    GenerateCenteredString(lengthOfMenu, "std::cin >>");
-
-   	Display::startMenu.push_back(GenerateEmptyLine(lengthOfMenu));
-
-    std::string tempString = Display::TOP_LEFT_CORNER_SINGLE;
-    for (int i = 0; i < 21; ++i) {
-      tempString += Display::HORIZONTAL_LINE_SINGLE;
-    }
-    tempString += Display::TOP_RIGHT_CORNER_SINGLE;
-
-    GenerateCenteredString(lengthOfMenu, tempString);
-    tempString = "";
-
-    GenerateCenteredString(lengthOfMenu, GenerateBoxMenuLine(22, "1 - New Game"));
-    GenerateCenteredString(lengthOfMenu, GenerateBoxMenuLine(22, "2 - Load Save"));
-    GenerateCenteredString(lengthOfMenu, GenerateBoxMenuLine(22, "3 - Instructions"));
-    GenerateCenteredString(lengthOfMenu, GenerateBoxMenuLine(22, ""));
-    GenerateCenteredString(lengthOfMenu, GenerateBoxMenuLine(22, "0 - Exit"));
-
-    tempString = Display::BOTTOM_LEFT_CORNER_SINGLE;
-    for (int i = 0; i < 21; ++i) {
-      tempString += Display::HORIZONTAL_LINE_SINGLE;
-    }
-    tempString += Display::BOTTOM_RIGHT_CORNER_SINGLE;
-
-    GenerateCenteredString(lengthOfMenu, tempString);
-    Display::startMenu.push_back(GenerateEmptyLine(lengthOfMenu));
-    Display::startMenu.push_back(GenerateEmptyLine(lengthOfMenu));
-
-    std::vector<std::string> bottomBorderHorizontals;
-
-    bottomBorderHorizontals.push_back(Display::BOTTOM_LEFT_CORNER + Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE);
-  	for (const std::string& str : Display::asciiArtTurboSchach[0]) {
-    	for (int i = 0; i < countVisibleCharacters(str); ++i) {
-      		string += Display::HORIZONTAL_LINE;
-    	}
-    	bottomBorderHorizontals.push_back(string);
-    	string = "";
-  	}
-    bottomBorderHorizontals.push_back(Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE + Display::HORIZONTAL_LINE + Display::BOTTOM_RIGHT_CORNER);
-
-	Display::startMenu.push_back(bottomBorderHorizontals);
-
-    int option;
-    for (const auto& row : Display::startMenu) {
-      for (const auto& col : row) {
-        if (col.find("std::cin >>") != std::string::npos) {
-          //std::cin >> option;
-        }
-        std::cout << col;
-      }
-      std::cout << std::endl;
-    }
+    	//CommandMenuVisualizer commandMenu = CommandMenuVisualizer(2);
+    	//commandMenu.DisplayElement();
+		//HistorieVisualizer historie = HistorieVisualizer(15, 2, "Player 1", "Player 2");
+		//historie.DisplayElement();
 
 
 
 
+
+        /*if () {
+      		Player* playerA = new Player("Player 1");
+      		Player* playerB = new Player("Player 2");
+
+      		Chessboard chessboard = Chessboard();
+      		chessboard.SetPlayers(playerA, playerB);
+
+      		chessboard.InitializeStartBoard();
+
+      		// Jetzt kann man Moves machen. Nach jedem Move müssen die ChessPieces aktualisiert werden.
+      		chessboard.UpdateChessPieces();
+
+      		//ChessboardVisualizerText* visualizer = new ChessboardVisualizerText();
+      		ChessboardVisualizer visualizer(&chessboard, 2);
+
+
+    	}*/
+	//}
+
 	/*std::cout << "Spieler A: ";
     std::string namePlayerA;
     getline(std::cin, namePlayerA);
@@ -190,30 +143,8 @@ int main() {
     std::string namePlayerB;
     getline(std::cin, namePlayerB);
 
-    Player* playerA = new Player(namePlayerA);
-    Player* playerB = new Player(namePlayerB);
-
-    Chessboard chessboard = Chessboard();
-    chessboard.SetPlayers(playerA, playerB);
-
-    chessboard.InitializeStartBoard();
-
-    // Jetzt kann man Moves machen. Nach jedem Move müssen die ChessPieces aktualisiert werden.
-    chessboard.UpdateChessPieces();
-
-    //ChessboardVisualizerText* visualizer = new ChessboardVisualizerText();
-    ChessboardVisualizerGraphic* visualizer = new ChessboardVisualizerGraphic();
-
-    while (chessboard.IsCheckmate() == false) {
-      visualizer->GenerateChessboard(&chessboard);
-      std::string move;
-      std::cout << "Move [" << ((chessboard.GetCurrentPlayer()->GetColor() == ChessPieceColor::White) ? "White" : "Black") << "] : ";
-      std::cin >> move;
-      chessboard.MoveChessPiece(move);
-    }
-
-    std::cout << "Game is over! - " << chessboard.GetOpponentPlayer()->GetName() << " has won the game!" << std::endl;*/
-
+    Player* playerA = new Player("1");
+    Player* playerB = new Player("2");*/