chore: removed code comments, used references where possible

Game.cpp

@@ -1,9 +1,4 @@
-//
-// Created by moonleay on 12/17/24.
-//
-
 #include "Game.h"
-#include "MazeParser.h"
 #include "Player.h"
 #include "Maze.h"
 #include "Exceptions/ExitGame.h"
@@ -16,25 +11,19 @@ using game_exceptions::UnkownAction;
 using game_exceptions::MovementNotPossible;
 using game_exceptions::ExitGame;
 
-namespace game // Namespace = Scope with name and no features
+namespace game
 {
     Game::Game(Maze& maze): maze(maze), player(0, 0)
     {
-        // Lese die Startpositon des Spielers aus dem eingelesenen Labyrinth aus
         PositionVector player_start_position = this->maze.get_player_start_position();
 
-        // Überschreibe den Spieler mit der gegebenen Startposition
         this->player = Player(player_start_position);
     }
 
-    PositionVector Game::handle_user_input(const char input)
+    PositionVector Game::handle_user_input(const char& input)
     {
-        // Erstelle einen Vector mit einer Bewegung von 0 und 0
         PositionVector movement_vector = PositionVector(0, 0);
 
-        // Kontrolliere, was der Spieler machen möchte. Speichere die erforderte Bewegung im Bewegungsvektor.
-        // Schreibe nachrichten in die Konsole,
-        // wenn nach Hilfe gefragt wird oder eine unbekannte Eingabe eingegeben wurde
         switch (input)
         {
         case 'w':
@@ -52,7 +41,6 @@ namespace game // Namespace = Scope with name and no features
         case 'q':
             throw ExitGame("Schoenen Tag noch!");
         case 'h':
-            // Schreibe hilfsreiche Tipps in die Konsole
             cout <<
                 "Du wurdest von einem Zauberer in ein Labyrinth gesperrt, nachdem du seine Künste beleidigt hast.\n"
                 << "Er laesst dich leben, wenn du es schaffst den Ausgang (Z) zu finden. Solltest du keinen Erfolg haben, laesst er dich verhungern.\n"
@@ -60,7 +48,6 @@ namespace game // Namespace = Scope with name and no features
                 << "Bewege dich mit 'w', 'a', 's' und 'd'.\n";
             break;
         default:
-            // Die gewollte Aktion kenne ich nicht. Melde Fehler dem Nutzer
             throw UnkownAction("Diese Eingabe kenne ich nicht. Gib 'h' ein, um eine Hilfe zu erhalten.");
         }
 
@@ -69,32 +56,25 @@ namespace game // Namespace = Scope with name and no features
 
     void Game::run_game()
     {
-        // Erstelle eine Variable für den Input
         char game_input;
 
-        // Durchlaufe die Hauptschleife des Spiels
+        // Hauptschleife
         while (true)
         {
-            // Kontrolliere, ob der Spieler an einem Geist gestorben ist
             if (this->maze.was_player_killed_by_ghost(player))
             {
                 cout << "Sie haben einen Geist getroffen! Game Over!\n";
                 break;
             }
 
-            // Zeige dem Spieler das Spielfeld
             this->maze.render(player);
 
-
-            // Kontrolliere, ob der Spieler schon das Ziel erreicht hat
             if (this->maze.is_player_at_goal(player))
             {
-                // Ziel erreicht! Herzlichen Glückwunsch!
                 cout << "Ziel erreicht! Herzlichen Glueckwunsch!\n";
                 break;
             }
 
-            // Lese Eingabe des Spielers
             cin >> game_input;
 
             PositionVector movement_vector = PositionVector(0, 0);
@@ -104,20 +84,15 @@ namespace game // Namespace = Scope with name and no features
                 movement_vector = handle_user_input(game_input);
             } catch (UnkownAction& err)
             {
-                // Diese Anweisung kenne ich nicht.
-                // Melde dies dem Spieler
                 cout << err.what() << "\n";
             }
 
-            // Kontrolliere gewollte Bewegung und setze sie um.
             try
             {
                 player.move(this->maze, movement_vector);
             }
             catch (MovementNotPossible& err)
             {
-                // Diese Bewegung ist nicht möglich!
-                // Gebe aus, warum.
                 cout << err.what() << "\n";
             }
         }

Game.h

@@ -1,6 +1,3 @@
-//
-// Created by moonleay on 12/17/24.
-//
 #include "Maze.h"
 #include "Player.h"
 
@@ -17,13 +14,13 @@ namespace game
         Player player;
 
     public:
-        Game(Maze& maze);
+        explicit Game(Maze& maze);
 
         /// Bearbeite die Eingabe des Spielers
         /// @param input Die Eingabe des Nutzers
         /// @return Der Bewegungsvektor, um den sich den Spieler bewegen möchte
         /// @throws UnkownAction Wenn die Eingabe des Spielers unbekannt ist
-        static PositionVector handle_user_input(char input);
+        static PositionVector handle_user_input(const char& input);
 
         /// Starte das Spiel
         void run_game();

Maze.cpp

@@ -1,7 +1,3 @@
-//
-// Created by moonleay on 12/13/24.
-//
-
 #include "Maze.h"
 #include "Player.h"
 #include "Exceptions/MalformedMaze.h"
@@ -18,62 +14,55 @@ namespace game
             throw MalformedMaze("Player oob");
     }
 
-    bool Maze::was_player_killed_by_ghost(Player player) const
+    bool Maze::was_player_killed_by_ghost(const 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
+    bool Maze::is_player_at_goal(const Player& player) const
     {
-        // Kontrolliere ob der Spieler am Ziel ist
         return this->field[player.get_pos().y][player.get_pos().x] == 'Z';
     }
 
-    bool Maze::is_pos_free(const PositionVector pos, const bool player_has_key) const
+    bool Maze::is_pos_free(const PositionVector& pos, const bool& player_has_key) const
     {
         if (pos.x < 0 || pos.y < 0 || pos.y > field.size() - 1 || pos.x > field[pos.y].size() - 1)
-            return false; // Zielposition ist außerhalb des Spielfelds
+            return false;
         if (field[pos.y][pos.x] == '#')
-            return false; // Zielposition ist eine Wand
+            return false;
         if (field[pos.y][pos.x] == 'T')
-            return player_has_key; // Zielposition ist eine Tür
+            return player_has_key;
-        return true; // Zielposition ist betretbar (ist keine Wand und auch nicht außerhalb des Spielfeldes)
+        return true;
     }
 
-    void Maze::render(Player player) const
+    void Maze::render(const Player& player) const
     {
         for (int y = 0; y < field.size(); ++y)
         {
-            // Für jede Reihe ...
             for (int x = 0; x < field[y].size(); ++x)
             {
-                // ... schreibe für jedes Element ...
                 if (y == player.get_pos().y && x == player.get_pos().x)
-                    cout << "S"; // ... 'S' wenn der aktuelle Eintrag die Position des Spielers ist
+                    cout << "S";
-                else // sonst
+                else
-                    cout << field[y][x]; // ... den tatsächlichen Eintrag
+                    cout << field[y][x];
-                cout << " "; // Füge ein Leerzeichen zwischen den Einträgen hinzu
+                cout << " ";
             }
-            cout << "\n"; // Beende die Reihe mit einem Zeilenumbruch
+            cout << "\n";
         }
     }
 
-    char Maze::get_field(PositionVector pos) const
+    char Maze::get_field(const 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)
+    void Maze::update_field(const PositionVector& pos, const char& target)
     {
-        // Aktuallisiere ein gegebens Feld dem gegebenen Wert
         this->field[pos.y][pos.x] = target;
     }
 
     PositionVector Maze::get_player_start_position() const
     {
-        // Gebe die Startposition des Spielers zurück
         return this->player_start_position;
     }
 } // game

Maze.h

@@ -1,6 +1,3 @@
-//
-// Created by moonleay on 12/13/24.
-//
 #include "std_lib_inc.h"
 #include "PositionVector.h"
 
@@ -9,7 +6,8 @@
 
 namespace game
 {
-  class Player; // Forward declaration
+  class Player;
+
   /// Ein Labyrinth.
   /// Besitzt ein Feld
   class Maze
@@ -28,32 +26,32 @@ namespace game
     /// Kontrolliere, ob der Spieler stirbt
     /// @param player Der Spieler
     /// @return Ob der Spieler tot ist
-    bool was_player_killed_by_ghost(Player player) const;
+    bool was_player_killed_by_ghost(const Player& player) const;
 
     /// Kontrolliere, ob der Spieler am Ziel ist
     /// @param pos Die Position des Spielers
     /// @return Ob der Spieler am Ziel ist
-    bool is_player_at_goal(Player player) const;
+    bool is_player_at_goal(const Player& player) const;
 
     /// Kontrolliere, ob eine bestimmte Position begehbar ist
     /// @param pos Die Position, die überprüft werden soll
     /// @param player_has_key If the player has at least one key
     /// @return Ob die Position begehbar ist
-    bool is_pos_free(PositionVector pos, bool player_has_key) const;
+    bool is_pos_free(const PositionVector& pos, const bool& player_has_key) const;
 
     /// Zeige das Spielfeld in der Konsole an
     /// @param pos Die Position des Spielers
-    void render(Player player) const;
+    void render(const Player& player) const;
 
     /// Kriege den Wert einer Position
     /// @param pos Die gewollte Position
     /// @return Der Wert der Position
-    char get_field(PositionVector pos) const;
+    char get_field(const PositionVector& pos) const;
 
     /// Ersetze den Wert von einer Position
     /// @param target_pos Die Position die ersetzt werden soll
     /// @param target Der Wert, auf den die Position gesetzt werden soll
-    void update_field(PositionVector pos, char target);
+    void update_field(const PositionVector& pos, const char& target);
 
     /// Kriege die Startposition des Spielers
     /// @return Die Startposition des Spielers

MazeParser.cpp

@@ -1,7 +1,3 @@
-//
-// Created by moonleay on 12/16/24.
-//
-
 #include "MazeParser.h"
 
 #include "Exceptions/ExitGame.h"
@@ -12,88 +8,61 @@ using game_exceptions::ExitGame;
 
 namespace game
 {
-    vector<int> MazeParser::request_numbers_from_user(const int amount_of_numbers)
+    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 schiefgelaufen sein, dann wirf eine Exception
             if (!cin)
                 throw MalformedMaze("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::validate_maze_element(const char target)
+    bool MazeParser::validate_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
+                return true;
-        // 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;
 
-        // 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 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 MalformedMaze("Cin failed while reading chars!");
 
-                // Verlasse das Spiel
                 if (input == 'q')
                     throw ExitGame("Schoenen Tag noch!");
 
-                // Kontrolliere, ob das Element in einem Labyrinth vorkommen darf
                 if (!validate_maze_element(input))
                     throw MalformedMaze("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);
     } // Beispieleingabe: `4 3 #.# #.K #T# #Z# 0 1`
 } // game

MazeParser.h

@@ -1,8 +1,4 @@
-//
+#include "std_lib_inc.h"
-// Created by moonleay on 12/16/24.
-//
-
-#include "Maze.h"
 
 #ifndef MAZEPARSER_H
 #define MAZEPARSER_H
@@ -22,18 +18,19 @@ namespace game
     /// Ist eine Konstante, darf also in global scope
     static const vector<char> valid_maze_elements = {'Z', '.', '#', 'A', 'K', 'T'};
 
+    class Maze;
     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);
+        static vector<int> request_numbers_from_user(const 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 validate_maze_element(char target);
+        static bool validate_maze_element(const char& target);
 
     public:
         /// Lese ein Labyrinth aus der Konsole

Player.cpp

@@ -1,7 +1,3 @@
-//
-// Created by moonleay on 12/12/24.
-//
-
 #include "std_lib_inc.h"
 #include "Player.h"
 #include "Maze.h"
@@ -13,7 +9,6 @@ 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 Variablen initialisieren müssen
   }
 
   Player::Player(const PositionVector pos) : pos(pos), keys_in_inventory(0)
@@ -22,39 +17,31 @@ namespace game
 
   PositionVector Player::get_pos() const
   {
-    // Gebe die aktuelle Position des Spielers zurück
     return this->pos;
   }
 
-  void Player::update_position(const PositionVector target)
+  void Player::update_position(const PositionVector& target)
   {
-    // Aktualisiere die aktuelle Position des Spielers
     this->pos = target;
   }
 
 
-  Maze Player::move(Maze& maze, const PositionVector move_vector)
+  Maze Player::move(Maze& maze, const PositionVector& move_vector)
   {
-    // Berechne die Position, zu der der Spieler sich bewegen möchte
     const PositionVector target_position = PositionVector(this->get_pos().x + move_vector.x,
                                                           this->get_pos().y + move_vector.y);
 
-    // Bewege den Spieler zu der gewollten Position, wenn diese frei ist
     if (maze.is_pos_free(target_position, this->has_key_available()))
     {
-      // Bewege Spieler zur neuen Position
       this->update_position(target_position);
 
-      // Kontrolliere das Feld nach speziellen Attributen
       switch (maze.get_field(target_position))
       {
-      case 'K': // Spieler steht auf einem Schlüssel.
+      case 'K':
-        // Gebe dem Spieler einen Schlüssel und ersetze das Feld mit einem leeren
         ++this->keys_in_inventory;
         maze.update_field(target_position, '.');
         break;
-      case 'T': // Spieler steht auf einer Tür
+      case 'T':
-        // Nehme dem Spieler einen Schlüssel weg und ersetze das Feld mit einem leeren
         --this->keys_in_inventory;
         maze.update_field(target_position, '.');
         break;

Player.h

@@ -1,6 +1,3 @@
-//
-// Created by moonleay on 12/12/24.
-//
 #include "PositionVector.h"
 
 #ifndef PLAYER_H
@@ -8,7 +5,8 @@
 
 namespace game
 {
-    class Maze; // use instead of include to speed up the compiler :)
+    class Maze;
+
     /// Ein Spieler.
     /// Besitzt einen veränderbaren Positionsvektor
     class Player
@@ -34,13 +32,13 @@ namespace game
 
         /// Aktuallisiere die Position des Spielers ohne weitere Checks
         /// @param target Das ziel
-        void update_position(PositionVector target);
+        void update_position(const PositionVector& target);
 
         /// Bewege den Splieler um den Bewegungsvektor, insofern die Zielposition begehbar ist
         /// @param maze Das Maze
         /// @param move_vector Die gewollte Bewegung
         /// @return Die neue Position des Spielers
-        Maze move(Maze& maze, PositionVector move_vector);
+        Maze move(Maze& maze, const PositionVector& move_vector);
 
         /// Check, if a player has at least one key
         /// @return If the player as an available key

PositionVector.cpp

@@ -1,21 +1,15 @@
-//
-// Created by moonleay on 12/12/24.
-//
-
 #include "PositionVector.h"
 
 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)
+  void PositionVector::update(const int& x, const int& y)
   {
-    // Aktualisiere die Werte des PositionVectors
     this->x = x;
     this->y = y;
   }

PositionVector.h

@@ -1,7 +1,3 @@
-//
-// Created by moonleay on 12/12/24.
-//
-
 #ifndef POSITION_H
 #define POSITION_H
 
@@ -25,7 +21,7 @@ namespace game
         /// Aktualisiere die Werte des Vectors
         /// @param x Die neue 'X'-Koordinate
         /// @param y Die neue 'Y'-Koordinate
-        void update(int x, int y);
+        void update(const int& x, const int& y);
     };
 } // game
 

main.cpp

@@ -25,18 +25,14 @@ int main()
 {
     try
     {
-        // Lass den Nutzer ein Maze eingeben
         Maze maze = MazeParser::request_maze_from_user();
 
-        // Erstelle eine Variable, in der wir den Spielstate speichern
         Game game = Game(maze);
 
-        // Starte das Spiel
         game.run_game();
     }
-    catch (MalformedMaze& err)
+    catch (MalformedMaze& _)
     {
-        // Das Labyrinth einlesen hat nicht geklappt. Gebe Fehlermeldung aus und beende das Programm.
         cout << "Fehler beim Einlesen des Labyrinths.\n";
     } catch (ExitGame& _)
     {