Implement first displays of new elements (StartMenu and Historie)

Chessboard/ChessboardVisualizerGraphic.cpp

@@ -1,5 +1,6 @@
 #include "../Chessboard/ChessboardVisualizerGraphic.hpp"
 #include "../ChessPieces/ChessPiecePosition.hpp"
+#include "../Visualizer/HistorieVisualizer.hpp"
 
 void ChessboardVisualizerGraphic::SetConsoleColor(Colors foreground, Colors background) {
   const std::string SEQ_FOREGROUND = "\x1b[3";
@@ -64,11 +65,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,6 +91,33 @@ void ChessboardVisualizerGraphic::GenerateChessboard(Chessboard* chessboard) {
     }
     if (rank == 1) GenerateTopOrBottomBorder(false);
   }
+}
+
+void ChessboardVisualizerGraphic::AddMenusToChessboard() {
+
+}
+
+void ChessboardVisualizerGraphic::GenerateChessboard(Chessboard* chessboard) {
+  ClearTerminal();
+
+  GeneratePlayers(chessboard);
+
+  temp(chessboard);
+
+  AddMenusToChessboard();
+
+  HistorieVisualizer history = HistorieVisualizer("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 +222,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);
 

Chessboard/ChessboardVisualizerGraphic.hpp

@@ -33,6 +33,8 @@ class ChessboardVisualizerGraphic : public ChessboardVisualizer {
     void GenerateFiles();
     void SetConsoleColor(Colors foreground, Colors background);
     void SetColorsForField();
+    void temp(Chessboard* chessboard);
+    void AddMenusToChessboard();
 
   public:
     ChessboardVisualizerGraphic() = default;

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

@@ -102,7 +102,7 @@
 
 ## 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,157 @@
+#include "BaseVisualizer.hpp"
+
+size_t BaseVisualizer::CountVisibleCharacters(const std::string& str) {
+    size_t count = 0;
+    /*for (const char& c : str) {
+        // UTF-8 Startbytes zählen (kein Fortsetzungsbyte)
+        if ((c & 0b11000000) != 0b10000000) {
+            ++count;
+        }
+    }*/
+    for (size_t i = 0; i < str.size(); ++i) {
+        // UTF-8 Startbytes zählen (kein Fortsetzungsbyte)
+        if ((str[i] & 0b11000000) != 0b10000000) {
+            ++count;
+        }
+    }
+    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;
+}
+
+std::string 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 += " ";
+        }
+    }
+    return result;
+}
+
+std::string BaseVisualizer::GenerateBoxMenuLine(const size_t length, const std::string& str, const bool single) {
+    std::string result = ((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE) + "  " + str;
+    while (CountVisibleCharacters(result) <= length) {
+        result += " ";
+    }
+    return result + ((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE);
+}
+
+std::string 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 += " ";
+    }
+
+    return result + ((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE);
+}
+
+void BaseVisualizer::ClearTerminal() {
+    std::cout << "\033[2J";
+}
+
+void BaseVisualizer::DisplayElement() {
+    for (const auto& row : display_vector) {
+        for (const auto& cell : row) {
+            if (cell.find("std::cin >>") != std::string::npos) {
+                //std::cin >> option;
+            }
+            std::cout << cell;
+        }
+        std::cout << std::endl;
+    }
+}
+
+size_t BaseVisualizer::CalculateMaxMenuWidth(const size_t longestStringLength) {
+  return longestStringLength + 2;
+}
+
+std::string 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;
+    }
+    return 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::display_vector.push_back({BaseVisualizer::GenerateEmptyLine(length, sinlge)});
+  }
+}
+
+std::string 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;
+    }
+
+    return result + ((top) ? ((single) ? BaseVisualizer::TOP_RIGHT_CORNER_SINGLE : BaseVisualizer::TOP_RIGHT_CORNER) : ((single) ? BaseVisualizer::BOTTOM_RIGHT_CORNER_SINGLE : BaseVisualizer::BOTTOM_RIGHT_CORNER));
+}
+
+std::string 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 = "";
+    }
+    return result;
+}
+
+std::string 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);
+
+    return result;
+}

Visualizer/BaseVisualizer.hpp

@@ -0,0 +1,63 @@
+#ifndef BASEVISUALIZER_H
+#define BASEVISUALIZER_H
+
+#include <string>
+#include <vector>
+#include <cmath>
+#include <iostream>
+
+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;
+
+    std::vector<std::vector<std::string>> display_vector;
+
+    std::string GenerateEmptyLine(const int lengthOfMenu, const bool single);
+    std::string GenerateBoxMenuLine(const size_t length, const std::string& str, const bool single);
+    std::string GenerateCenteredString(const size_t widthOfMenu, const std::string& str, const bool single);
+    void CalculateMaxMenuWidth();
+    size_t CalculateMaxMenuWidth(const size_t longestStringLength);
+    std::string GenerateTopBottomBorder(const size_t totalLength, const bool top, const bool single);
+    void AddEmptyLines(const size_t lines, const size_t length, const bool sinlge);
+    std::string GenerateTableTopBottom(const size_t totalLength, const bool top, const bool single);
+    std::string GenerateTableLine(const float length, const std::vector<std::string>& str, const bool single);
+    std::string GenerateTableSeperator(const float length, const bool single);
+
+  private:
+    virtual void GenerateMenu() = 0;
+
+  public:
+    virtual ~BaseVisualizer() = default;
+    static void ClearTerminal();
+    void DisplayElement();
+    size_t static GetSumAllCharsFromVector(const std::vector<std::string>& vec);
+    size_t static CountVisibleCharacters(const std::string& str);
+    BaseVisualizer(size_t longestStringLength) : MAX_MENU_WIDTH(BaseVisualizer::CalculateMaxMenuWidth(longestStringLength))  {}
+
+};
+
+#endif //BASEVISUALIZER_H

Visualizer/HistorieVisualizer.cpp

@@ -0,0 +1,19 @@
+#include "HistorieVisualizer.hpp"
+
+void HistorieVisualizer::GenerateMenu() {
+    BaseVisualizer::display_vector.push_back({"Historie"});
+    BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateTableTopBottom(MAX_MENU_WIDTH, true, true)});
+
+    BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateTableLine(MAX_MENU_WIDTH, {HistorieVisualizer::PLAYER1, HistorieVisualizer::PLAYER2}, true)});
+    BaseVisualizer::display_vector.push_back({BaseVisualizer::BaseVisualizer::GenerateTableSeperator(MAX_MENU_WIDTH, true)});
+
+    for (size_t i = 0; i < 5; i++) {
+        BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateTableLine(MAX_MENU_WIDTH, {"", ""}, true)});
+    }
+
+    BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateTableTopBottom(MAX_MENU_WIDTH, false, true)});
+}
+
+std::vector<std::vector<std::string>> HistorieVisualizer::GetDisplayVector() {
+  return BaseVisualizer::display_vector;
+}

Visualizer/HistorieVisualizer.hpp

@@ -0,0 +1,22 @@
+#ifndef HISTORIEVISUALIZER_HPP
+#define HISTORIEVISUALIZER_HPP
+
+#include "BaseVisualizer.hpp"
+
+class HistorieVisualizer : public BaseVisualizer {
+    private:
+      const std::string PLAYER1;
+      const std::string PLAYER2;
+      std::vector<std::vector<std::string>> histories;
+
+      void GenerateMenu() override;
+
+    public:
+      HistorieVisualizer(const std::string& p1, const std::string& p2) :
+        BaseVisualizer(41), histories(5, std::vector<std::string>(2, "")), PLAYER1(p1), PLAYER2(p2) {
+          HistorieVisualizer::GenerateMenu();
+      };
+      std::vector<std::vector<std::string>> GetDisplayVector();
+};
+
+#endif //HISTORIEVISUALIZER_HPP

Visualizer/StartMenuVisualizer.cpp

@@ -0,0 +1,34 @@
+#include "StartMenuVisualizer.hpp"
+
+void StartMenuVisualizer::GenerateMenu() {
+  BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, true, false)});
+
+  BaseVisualizer::AddEmptyLines(2, MAX_MENU_WIDTH, false);
+
+  for (const auto& i : StartMenuVisualizer::ACSII_ART_TURBO_SCHACH) {
+    BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, i[0], false)});
+  }
+
+  BaseVisualizer::AddEmptyLines(2, MAX_MENU_WIDTH, false);
+
+  BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, "Welcome to TurboSchach!", false)});
+
+  BaseVisualizer::AddEmptyLines(2, MAX_MENU_WIDTH, false);
+
+  BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, "Please select one of the menu options:", false)});
+  BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, "std::cin >>", false)});
+
+  BaseVisualizer::AddEmptyLines(1, MAX_MENU_WIDTH, false);
+
+  BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, BaseVisualizer::GenerateTopBottomBorder(24, true, true), false)});
+
+  for (const auto& i : StartMenuVisualizer::MENU_OPTIONS) {
+    BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, BaseVisualizer::GenerateBoxMenuLine(22, i[0], true), false)});
+  }
+
+  BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateCenteredString(MAX_MENU_WIDTH, BaseVisualizer::GenerateTopBottomBorder(24, false, true), false)});
+
+  BaseVisualizer::AddEmptyLines(2, MAX_MENU_WIDTH, false);
+
+  BaseVisualizer::display_vector.push_back({BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, false, false)});
+}

Visualizer/StartMenuVisualizer.hpp

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

main.cpp

@@ -5,185 +5,27 @@
 #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 <iostream>
 #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;
-}
 
-int GetSumAllCharsFromVector(const std::vector<std::string>& vec) {
-  	int sum = 0;
-    for (const std::string& str : vec) {
-      sum += countVisibleCharacters(str);
-    }
-    return sum;
-}
-
-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);
-      } else {
-        string += " ";
-      }
-    }
-    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 += " ";
-  }
-
-  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;
-}
 
 
 int main() {
     SetConsoleOutputCP(CP_UTF8);
-	std::cout << "\033[2J";
 
+    //BaseVisualizer::ClearTerminal();
 
-	int widthOfStartMenu = Display::asciiArtTurboSchach.size() + 4;
+    StartMenuVisualizer startMenu = StartMenuVisualizer();
+    startMenu.DisplayElement();
 
-    std::vector<std::string> temp;
-
-    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);
-      }
-      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;
-    }
-
-
-
-
-	/*std::cout << "Spieler A: ";
+	std::cout << "Spieler A: ";
     std::string namePlayerA;
     getline(std::cin, namePlayerA);
     std::cout << "Spieler B: ";
@@ -212,10 +54,7 @@ int main() {
       chessboard.MoveChessPiece(move);
     }
 
-    std::cout << "Game is over! - " << chessboard.GetOpponentPlayer()->GetName() << " has won the game!" << std::endl;*/
-
-
-
+    std::cout << "Game is over! - " << chessboard.GetOpponentPlayer()->GetName() << " has won the game!" << std::endl;
 
     return 0;
 }