Merge pull request 'Review Projekt 4' (#1) from Jbrass/epr24pr42-ojanssen2:review into main

Reviewed-on: University/epr24pr42-ojanssen2#1

.gitignore

@@ -8,5 +8,5 @@
 !Makefile
 !.gitignore
 !.gitattributes
-
+!cmake-build-debug
 !*/

src/Environment/Game.h

@@ -11,6 +11,7 @@ namespace game
     /// Eine Instanz des Spiels
     class Game
     {
+
     private:
         /// Das Labyrinth
         Maze maze;
@@ -23,6 +24,7 @@ namespace game
         /// 
         bool infomode_enabled;
 
+
     public:
         explicit Game(Maze& maze);
 

src/Environment/Maze.cpp

@@ -1,36 +1,34 @@
 #include "Maze.h"
+#include "../Entities/Entity.h"
 #include "../Entities/Player.h"
 #include "../Exceptions/MalformedMaze.h"
-#include "../Entities/Entity.h"
-#include "../Util/MathUtil.h"
 
 using game_exceptions::MalformedMaze;
+namespace game {
+    /// Ist eine Konstante, darf also in global scope
+    static const vector<char> valid_maze_elements = {'Z', '.', '#', 'A', 'K', 'T', 'B', 'C'};
+    /// Welche Geistertypen es gibt
+    static const vector<char> valid_enemies = {'A', 'B', 'C'};
+    /// Die Maximale Labyrinthgröße
+    static constexpr int MAX_MAZE_SIZE = 20;
 
-namespace game
+    Maze::Maze(const vector<vector<char>> &play_field, const vector<int> &player_start_position,
-{
+               const vector<Entity> &enemies) :
-    class MathUtil;
+        field(play_field), player_start_position(Vector2d{player_start_position[1], player_start_position[0]}),
-
+        enemies(enemies) {
-    Maze::Maze(const vector<vector<char>>& play_field, const vector<int>& player_start_position, const vector<Entity>& enemies):
-        field(play_field),
-        player_start_position(Vector2d{player_start_position[1], player_start_position[0]}),
-        enemies(enemies)
-    {
         if (!this->is_pos_free(this->player_start_position, false))
             throw MalformedMaze("Player oob");
     }
 
-    bool Maze::was_player_killed_by_ghost(const Player& player) const
+    bool Maze::was_player_killed_by_ghost(const Player &player) const {
-    {
         return this->field[player.get_pos().y][player.get_pos().x] == 'A';
     }
 
-    bool Maze::is_player_at_goal(const Player& player) const
+    bool Maze::is_player_at_goal(const Player &player) const {
-    {
         return this->field[player.get_pos().y][player.get_pos().x] == 'Z';
     }
 
-    bool Maze::is_pos_free(const Vector2d& pos, const bool& player_has_key) const
+    bool Maze::is_pos_free(const Vector2d &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;
         if (field[pos.y][pos.x] == '#')
@@ -40,12 +38,9 @@ namespace game
         return true;
     }
 
-    void Maze::render(const Player& player, const vector<Entity>& entities, const bool& infomode_enabled)
+    void Maze::render(const Player &player, const vector<Entity> &entities, const bool &infomode_enabled) {
-    {
+        for (int y = 0; y < field.size(); ++y) {
-        for (int y = 0; y < field.size(); ++y)
+            for (int x = 0; x < field[y].size(); ++x) {
-        {
-            for (int x = 0; x < field[y].size(); ++x)
-            {
                 if (y == player.get_pos().y && x == player.get_pos().x)
                     cout << "S";
                 else {
@@ -60,8 +55,7 @@ namespace game
                 }
                 cout << " ";
             }
-            if (y == 0 && infomode_enabled)
+            if (y == 0 && infomode_enabled) {
-            {
                 const int steps = this->calculate_steps_until_win(player.get_pos(), 5);
                 if (steps < 999)
                     cout << steps << " Schritte bis zum Ziel";
@@ -70,20 +64,11 @@ namespace game
         }
     }
 
-    char Maze::get_field(const Vector2d& pos) const
+    char Maze::get_field(const Vector2d &pos) const { return this->field[pos.y][pos.x]; }
-    {
-        return this->field[pos.y][pos.x];
-    }
 
-    void Maze::update_field(const Vector2d& pos, const char& target)
+    void Maze::update_field(const Vector2d &pos, const char &target) { this->field[pos.y][pos.x] = target; }
-    {
-        this->field[pos.y][pos.x] = target;
-    }
 
-    Vector2d Maze::get_player_start_position() const
+    Vector2d Maze::get_player_start_position() const { return this->player_start_position; }
-    {
-        return this->player_start_position;
-    }
 
     Vector2d Maze::get_delta_vector(const Vector2d &pos1, const Vector2d &pos2) const {
         int x_diff = pos1.x - pos2.x;
@@ -100,16 +85,78 @@ namespace game
         if (steps <= 0)
             return 999;
 
-        vector<int> i;
+        return 1 + std::min({this->calculate_steps_until_win(position.get_new_updated(0, -1), steps - 1),
-        i.push_back(this->calculate_steps_until_win(position.get_new_updated(0, -1), steps - 1));
+                             this->calculate_steps_until_win(position.get_new_updated(0, 1), steps - 1),
-        i.push_back(this->calculate_steps_until_win(position.get_new_updated(0, 1), steps - 1));
+                             this->calculate_steps_until_win(position.get_new_updated(1, 0), steps - 1),
-        i.push_back(this->calculate_steps_until_win(position.get_new_updated(1, 0), steps - 1));
+                             this->calculate_steps_until_win(position.get_new_updated(-1, 0), steps - 1)});
-        i.push_back(this->calculate_steps_until_win(position.get_new_updated(-1, 0), steps - 1));
-
-        return MathUtil::get_min(i) + 1;
     }
 
-    vector<Entity> Maze::get_entities() {
+    vector<Entity> Maze::get_entities() { return this->enemies; }
-      return this->enemies;
+
+    vector<int> Maze::request_numbers_from_user(const int &amount_of_numbers) {
+        int input;
+        vector<int> list;
+
+        for (int i = 0; i < amount_of_numbers; ++i) {
+            cin >> input;
+            if (!cin)
+                throw MalformedMaze("Cin failed while reading numbers!");
+
+            if (input > MAX_MAZE_SIZE)
+                throw MalformedMaze("This maze is too big");
+            list.push_back(input);
         }
-} // game
+
+        return list;
+    }
+
+    bool Maze::validate_maze_element(const char &target) {
+        for (const char c: valid_maze_elements)
+            if (c == target)
+                return true;
+        return false;
+    }
+
+    bool Maze::is_valid_enemy(const char &target) {
+        for (const char c: valid_enemies)
+            if (c == target)
+                return true;
+        return false;
+    }
+
+    Maze Maze::request_maze_from_user() {
+        vector<int> maze_size = request_numbers_from_user(2);
+
+        char input;
+        vector<vector<char>> field;
+        vector<Entity> enemies;
+
+        for (int y = 0; y < maze_size[0]; ++y) {
+            vector<char> row;
+            for (int x = 0; x < maze_size[1]; ++x) {
+                cin >> input;
+                if (!cin)
+                    throw MalformedMaze("Cin failed while reading chars!");
+
+                // I don't think that this is needed. I doubt that they test the check for this one ~Eric
+                // if (input == 'q')
+                //    throw ExitGame("Schoenen Tag noch!");
+
+                if (!validate_maze_element(input))
+                    throw MalformedMaze("The given input is not a valid element of a maze!");
+                if (is_valid_enemy(input)) {
+                    enemies.push_back(Entity({x, y}, input));
+                    row.push_back('.');
+                } else {
+                    row.push_back(input);
+                }
+            }
+
+            field.push_back(row);
+        }
+
+        vector<int> player_start_pos = request_numbers_from_user(2);
+
+        return {field, player_start_pos, enemies};
+    } // Beispieleingabe: `4 3 #.# #.K #T# #Z# 0 1`
+} // namespace game

src/Environment/Maze.h

@@ -1,19 +1,19 @@
-#include "../std_lib_inc.h"
-#include "../Util/Vector2d.h"
-
 #ifndef MAZE_H
 #define MAZE_H
 
-namespace game
+#include "../Util/Vector2d.h"
-{
+#include "../std_lib_inc.h"
+
+namespace game {
     class Player;
     class Entity;
+    /// Ist eine Konstante, darf also in global scope
 
     /// Ein Labyrinth.
     /// Besitzt ein Feld
-  class Maze
+    class Maze {
-  {
         // class -> members private by default
+
     private:
         /// Das Spielfeld
         vector<vector<char>> field;
@@ -21,10 +21,22 @@ namespace game
         Vector2d player_start_position;
         /// Eine Liste an Gegnern
         vector<Entity> enemies;
-
+        /// Erlaubte Zeichen in einem Labyrinth
+        /* Legende
+         * S - Spieler
+         * Z - Ziel
+         * . - Leerer Raum (begehbar)
+         * # - Wand
+         * A - Animaltronic
+         * K - Schlüssel
+         * T - Tür
+         * B - Bowie
+         * C - Connellys
+         */
     public:
         /// Das Spielfeld
-    Maze(const Vector<Vector<char>>& play_field, const Vector<int>& player_start_position, const Vector<Entity>& enemies);
+        Maze(const Vector<Vector<char>> &play_field, const Vector<int> &player_start_position,
+             const Vector<Entity> &enemies);
         /// Kontrolliere, ob der Spieler stirbt
         /// @param player Der Spieler
         /// @return Ob der Spieler tot ist
@@ -74,7 +86,27 @@ namespace game
 
         /// Kriege alle eingelesenen Entities
         vector<Entity> get_entities();
+        /// Lese ein Labyrinth aus der Konsole
+        /// @return Das Labyrinth
+        /// @throws runtime_exception Falls die Eingabe nicht korrekt verlaufen ist.
+        static Maze request_maze_from_user();
+
+    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(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(const char &target);
+
+        /// Ob der angegebene char in valider Geist ist
+        /// @param target Der zu kontrollierende Wert
+        /// @returns Ob der Wert ein Valider Geist ist
+        static bool is_valid_enemy(const char &target);
     };
-} // game
+} // namespace game
 
 #endif // MAZE_H

src/Util/MathUtil.cpp

@@ -1,11 +0,0 @@
-#include "MathUtil.h"
-
-namespace game {
-    int MathUtil::get_min(const vector<int>& numbers) {
-        int i = numbers[0];
-        for (const int j : numbers)
-            if (j < i)
-                i = j;
-        return i;
-    }
-} // game

src/Util/MathUtil.h

@@ -1,16 +0,0 @@
-#include "../std_lib_inc.h"
-#ifndef UTIL_H
-#define UTIL_H
-
-namespace game
-{
-    class MathUtil{
-        public:
-            /// Gebe die minimale Nummer aus einer Liste zurück
-            /// @param numbers Eine liste an nummern
-            /// @returns Die kleinste Nummer
-            static int get_min(const vector<int>& numbers);
-    };
-} // game
-
-#endif //UTIL_H

src/Util/MazeParser.cpp

@@ -1,85 +0,0 @@
-#include "MazeParser.h"
-#include "../Environment/Maze.h"
-#include "../Exceptions/MalformedMaze.h"
-#include "../Entities/Entity.h"
-
-using game_exceptions::MalformedMaze;
-using game::Entity;
-
-namespace game
-{
-    vector<int> MazeParser::request_numbers_from_user(const int& amount_of_numbers)
-    {
-        int input;
-        vector<int> list;
-
-        for (int i = 0; i < amount_of_numbers; ++i)
-        {
-            cin >> input;
-            if (!cin)
-                throw MalformedMaze("Cin failed while reading numbers!");
-
-            if (input > MAX_MAZE_SIZE)
-                throw MalformedMaze("This maze is too big");
-            list.push_back(input);
-        }
-
-        return list;
-    }
-
-    bool MazeParser::validate_maze_element(const char& target)
-    {
-        for (const char c : valid_maze_elements)
-            if (c == target)
-                return true;
-        return false;
-    }
-
-    bool MazeParser::is_valid_enemy(const char& target) {
-        for (const char c : valid_enemies) 
-            if (c == target)
-                return true;
-        return false;
-    }
-
-    Maze MazeParser::request_maze_from_user()
-    {
-        vector<int> maze_size = request_numbers_from_user(2);
-
-        char input;
-        vector<vector<char>> field;
-        vector<Entity> enemies;
-
-        for (int y = 0; y < maze_size[0]; ++y)
-        {
-            vector<char> row;
-            for (int x = 0; x < maze_size[1]; ++x)
-            {
-                cin >> input;
-                if (!cin)
-                    throw MalformedMaze("Cin failed while reading chars!");
-
-                // I don't think that this is needed. I doubt that they test the check for this one ~Eric
-                // if (input == 'q')
-                //    throw ExitGame("Schoenen Tag noch!");
-
-                if (!validate_maze_element(input))
-                    throw MalformedMaze("The given input is not a valid element of a maze!");
-                if (is_valid_enemy(input))
-                {
-                    enemies.push_back(Entity({x, y}, input));
-                    row.push_back('.');
-                }
-                else {
-                    row.push_back(input);
-                }
-            }
-
-            field.push_back(row);
-        }
-
-        vector<int> player_start_pos = request_numbers_from_user(2);
-
-        return {field, player_start_pos, enemies};
-    } // Beispieleingabe: `4 3 #.# #.K #T# #Z# 0 1`
-} // game

src/Util/MazeParser.h

@@ -1,54 +0,0 @@
-#include "../std_lib_inc.h"
-
-#ifndef MAZEPARSER_H
-#define MAZEPARSER_H
-
-/* Legende
- * S - Spieler
- * Z - Ziel
- * . - Leerer Raum (begehbar)
- * # - Wand
- * A - Animaltronic
- * K - Schlüssel
- * T - Tür
- * B - Bowie
- * C - Connellys
- */
-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', 'B', 'C'};
-    /// Welche Geistertypen es gibt
-    static const vector<char> valid_enemies = {'A', 'B', 'C'};
-    /// Die Maximale Labyrinthgröße
-    static constexpr int MAX_MAZE_SIZE = 20;
-
-    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(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(const char& target);
-
-        /// Ob der angegebene char in valider Geist ist
-        /// @param target Der zu kontrollierende Wert
-        /// @returns Ob der Wert ein Valider Geist ist
-        static bool is_valid_enemy(const char& target);
-
-    public:
-        /// Lese ein Labyrinth aus der Konsole
-        /// @return Das Labyrinth
-        /// @throws runtime_exception Falls die Eingabe nicht korrekt verlaufen ist.
-        static Maze request_maze_from_user();
-    };
-} // game
-
-#endif //MAZEPARSER_H

src/main.cpp

@@ -20,7 +20,7 @@ int main()
     GameState state = GameState::RUNNING;
     try
     {
-        Maze maze = MazeParser::request_maze_from_user();
+        Maze maze = Maze::request_maze_from_user();
 
         Game game = Game(maze);