University/epr24pr3_ojanssen2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: removed code comments, used references where possible

Browse source
This commit is contained in:
moonleay 2024-12-18 09:12:00 +01:00
parent a4cf0bf18f
commit b416bb3d87
Signed by: moonleay
GPG key ID: 82667543CCD715FB
11 changed files with 46 additions and 150 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
Game.cpp
View file

@ -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";
}
}

7
Game.h
View file

@ -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();

41
Maze.cpp
View file

@ -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 true; // Zielposition ist betretbar (ist keine Wand und auch nicht außerhalb des Spielfeldes)
return player_has_key;
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
else // sonst
cout << field[y][x]; // ... den tatsächlichen Eintrag
cout << " "; // Füge ein Leerzeichen zwischen den Einträgen hinzu
cout << "S";
else
cout << field[y][x];
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

18
Maze.h
View file

@ -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

37
MazeParser.cpp
View file

@ -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
// Sollte es kein Element in der Liste geben, welches dem gegebenen Entspricht, dann ist das Element nicht erlaubt.
return true;
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

11
MazeParser.h
View file

@ -1,8 +1,4 @@
//
// Created by moonleay on 12/16/24.
//
#include "Maze.h"
#include "std_lib_inc.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

21
Player.cpp
View file

@ -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.
// Gebe dem Spieler einen Schlüssel und ersetze das Feld mit einem leeren
case 'K':
++this->keys_in_inventory;
maze.update_field(target_position, '.');
break;
case 'T': // Spieler steht auf einer Tür
// Nehme dem Spieler einen Schlüssel weg und ersetze das Feld mit einem leeren
case 'T':
--this->keys_in_inventory;
maze.update_field(target_position, '.');
break;

10
Player.h
View file

@ -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

8
PositionVector.cpp
View file

@ -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;
}

6
PositionVector.h
View file

@ -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

6
main.cpp
View file

@ -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& _)
{