epr24pr42-ojanssen2/Maze.h

#ifndef MAZE_H
#define MAZE_H

#include "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 -> members private by default

    private:
        /// Das Spielfeld
        vector<vector<char>> field;
        /// Die Startposition des Spielers
        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);
        /// Kontrolliere, ob der Spieler stirbt
        /// @param player Der Spieler
        /// @return Ob der Spieler tot ist
        bool was_player_killed_by_ghost(const Player &player) const;

        /// Kontrolliere, ob der Spieler am Ziel ist
        /// @param player Der Spieler
        /// @return Ob der Spieler am Ziel ist
        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(const Vector2d &pos, const bool &player_has_key) const;

        /// Zeige das Spielfeld in der Konsole an
        /// @param player Der Spieler
        /// @param entities Die Entities auf dem Spielfeld
        /// @param infomode_enabled Ob der Infomode aktiv ist
        void render(const Player &player, const vector<Entity> &entities, const bool &infomode_enabled);

        /// Kriege den Wert einer Position
        /// @param pos Die gewollte Position
        /// @return Der Wert der Position
        char get_field(const Vector2d &pos) const;

        /// Ersetze den Wert von einer Position
        /// @param pos Die Position die ersetzt werden soll
        /// @param target Der Wert, auf den die Position gesetzt werden soll
        void update_field(const Vector2d &pos, const char &target);

        /// Kriege die Startposition des Spielers
        /// @return Die Startposition des Spielers
        Vector2d get_player_start_position() const;

        /// Berrechne den Abstand zwischen zwei Vektoren
        /// @return Der Abstand als Differenzvektor
        Vector2d get_delta_vector(const Vector2d &pos1, const Vector2d &pos2) const;

        /// Berechne wie viele Schritte benötigt werden, um das Labyrinth zu schaffen
        /// @warning Steps nicht zu groß setzen! Diese Funktion ist 4-fach rekursiv!
        /// @param position Die Startposition
        /// @param steps Wie viele Schritte maximal gegangen werden sollten
        /// @returns Wie viele Schritte benötigt werden
        int calculate_steps_until_win(Vector2d position, const int &steps);

        /// 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);
    };
} // namespace game

#endif // MAZE_H