chore: improved comments

Maze.cpp

@@ -11,15 +11,18 @@ namespace game
         field(play_field),
         player_start_position(player_start_position)
     {
+        // Wir brauchen keinen Inhalt in diesem Konstruktor, da wir nur die Variablen initialisieren müssen
     }
 
     bool Maze::was_player_killed_by_ghost(Player player) const
     {
+        // Kontrolliere ob der Spieler an einem Geist gestorben ist
         return this->field[player.get_pos().y][player.get_pos().x] == 'A';
     }
 
     bool Maze::is_player_at_goal(Player player) const
     {
+        // Kontrolliere ob der Spieler am Ziel ist
         return this->field[player.get_pos().y][player.get_pos().x] == 'Z';
     }
 
@@ -54,16 +57,19 @@ namespace game
 
     char Maze::get_field(PositionVector pos) const
     {
+        // Gebe das Element der gewollten Position zurück
         return this->field[pos.y][pos.x];
     }
 
     void Maze::update_field(PositionVector pos, char target)
     {
+        // Aktuallisiere ein gegebens Feld dem gegebenen Wert
         this->field[pos.y][pos.x] = target;
     }
 
     vector<int> Maze::get_player_start_position()
     {
+        // Gebe die Startposition des Spielers zurück
         return this->player_start_position;
     }
 } // game

Maze.h

@@ -7,15 +7,6 @@
 #ifndef MAZE_H
 #define MAZE_H
 
-/* Legende
- * S - Spieler
- * Z - Ziel
- * . - Leerer Raum (begehbar)
- * # - Wand
- * A - Geist
- * K - Schlüssel
- * T - Tür
- */
 namespace game
 {
   class Player; // Forward declaration

MazeParser.cpp

@@ -8,37 +8,84 @@ namespace game
 {
     vector<int> MazeParser::request_numbers_from_user(const int amount_of_numbers)
     {
+        // Erstelle eine Variable für die Eingabe der Zahl(en)
         int input;
+
+        // Erstelle eine Liste für die einzulesenden Nummern
         vector<int> list;
+
+        // Lese soviel ein, wie gefragt
         for (int i = 0; i < amount_of_numbers; ++i)
         {
+            // Lese Zahl ein
             cin >> input;
+
+            // Sollte etwas schief gelaufen sein, dann wirf eine Exception
             if (!cin)
                 throw runtime_error("Cin failed while reading numbers!");
+
+            // Schreibe die gelesene Zahl auf die Liste
             list.push_back(input);
         }
+
+        // Gebe die Liste zurück
         return list;
     }
 
+    bool MazeParser::is_valid_maze_element(const char target)
+    {
+        // Gehe jedes erlaubte Element durch und
+        for (const char c : valid_maze_elements)
+            // Gucke, ob es das gegebene Element ist
+            if (c == target)
+                return true; // Gebe wahr zurück, wenn das Element in der Liste ist
+        // Sollte es kein Element in der Liste geben, welches dem gegebenen Entspricht, dann ist das Element nicht erlaubt.
+        return false;
+    }
+
+
 
     Maze MazeParser::request_maze_from_user()
     {
+        // Lese aus, wie groß das Labyrinth sein soll
         vector<int> maze_size = request_numbers_from_user(2);
+
+        // Erstelle eine Variable für den Labyrinth-Input
         char input;
+
+        // Erstelle ein leeres Feld
         vector<vector<char>> field;
-        for (int i = 0; i < maze_size[0]; ++i)
+
+        // Lese das eingegebene Labyrinth ein
+        for (int y = 0; y < maze_size[0]; ++y)
         {
+            // Für jede Reihe erstelle eine Variable...
             vector<char> row;
-            for (int j = 0; j < maze_size[1]; ++j)
+            for (int x = 0; x < maze_size[1]; ++x)
             {
+                // und lese jedes Element der Reihe ein
                 cin >> input;
+
+                // Werfe eine Exception, wenn der Input nicht lesbar ist, d.h. Nutzer hat eine Falsch eingabe getätigt.
                 if (!cin)
                     throw runtime_error("Cin failed while reading chars!");
+
+                // Kontrolliere, ob das Element in einem Labyrinth vorkommen darf
+                if (!is_valid_maze_element(input))
+                    throw runtime_error("The given input is not a valid element of a maze!");
+
+                // Schreibe den eingelesenen Wert in die aktuelle Reihe
                 row.push_back(input);
             }
+
+            // Schreibe die fertige Reihe in das Feld
             field.push_back(row);
         }
+
+        // Lese die Startposition des Spielers aus
         vector<int> player_start_pos = request_numbers_from_user(2);
+
+        // Gebe die Daten als Spielfeld zurück
         return Maze(field, player_start_pos);
-    } // `4 3 #.# #.K #T# #Z# 0 1`
+    } // Beispieleingabe: `4 3 #.# #.K #T# #Z# 0 1`
 } // game

MazeParser.h

@@ -7,16 +7,35 @@
 #ifndef MAZEPARSER_H
 #define MAZEPARSER_H
 
+/* Legende
+ * S - Spieler
+ * Z - Ziel
+ * . - Leerer Raum (begehbar)
+ * # - Wand
+ * A - Geist
+ * K - Schlüssel
+ * T - Tür
+ */
 namespace game
 {
+    /// Erlaubte Zeichen in einem Labyrinth
+    /// Ist eine Konstante, darf also in global scope
+    static const vector<char> valid_maze_elements = {'Z', '.', '#', 'A', 'K', 'T'};
+
     class MazeParser
     {
     private:
+
         /// Lese eine bestimmte Anzahl an Nummern aus der Konsole
         /// @param amount_of_numbers Wie viele Nummern eingelesen werden sollen
         /// @return Die eingelesenen Nummern
         static vector<int> request_numbers_from_user(int amount_of_numbers);
 
+        /// Kontrolliere, ob ein Zeichen im Labyrinth vorkommen darf
+        /// @param target Das Zeichen, welches Kontrolliert werden soll
+        /// @return Ob das gegebene Zeichen in einem Labyrinth vorkommen darf
+        static bool is_valid_maze_element(char target);
+
     public:
         /// Lese ein Labyrinth aus der Konsole
         /// @return Das Labyrinth

Player.cpp

@@ -10,16 +10,18 @@ namespace game
 {
   Player::Player(const int target_x, const int target_y): pos(target_x, target_y), keys_in_inventory(0)
   {
-    // Wir brauchen keinen Inhalt in diesem Konstruktor, da wir nur die position speichern müssen
+    // Wir brauchen keinen Inhalt in diesem Konstruktor, da wir nur die Variablen initialisieren müssen
   }
 
   PositionVector Player::get_pos() const
   {
+    // Gebe die aktuelle Position des Spielers zurück
     return this->pos;
   }
 
   void Player::update_position(const PositionVector target)
   {
+    // Aktualisiere die aktuelle Position des Spielers
     this->pos = target;
   }
 

PositionVector.cpp

@@ -8,12 +8,14 @@ namespace game
 {
   PositionVector::PositionVector(const int x, const int y)
   {
+    // Setze die Werte des PositionVectors
     this->x = x;
     this->y = y;
   }
 
   void PositionVector::update(const int x, const int y)
   {
+    // Aktualisiere die Werte des PositionVectors
     this->x = x;
     this->y = y;
   }

main.cpp

@@ -14,17 +14,22 @@ const vector<int> player_start_position = {4, 0};
 
 int main()
 {
+    // Erstelle eine Variable, in der wir das eingelesene Labyrinth speichern
     Maze maze;
+
     try
     {
+        // Lese das Labyrinth ein
         maze = MazeParser::request_maze_from_user();
     }
     catch (...)
     {
+        // Das Labyrinth einlesen hat nicht geklappt. Gebe Fehlermeldung aus und beende das Programm.
         cout << "Fehler beim Einlesen des Labyrinths.\n";
         return 0;
     }
 
+    // Lese die Startpositon des Spielers aus dem eingelesenen Labyrinth aus
     vector<int> player_start_position = maze.get_player_start_position();
 
     // Erstelle einen Spieler mit der gegebenen start position