diff --git a/Game.cpp b/Game.cpp
index e2e7da0..3574857 100644
--- a/Game.cpp
+++ b/Game.cpp
@@ -18,19 +18,16 @@ using game_exceptions::ExitGame;
 
 namespace game // Namespace = Scope with name and no features
 {
-    Game::Game(): maze({}, {}), player(0, 0)
+    Game::Game(Maze& maze): maze(maze), player(0, 0)
     {
-        // Lese das Labyrinth ein
-        maze = MazeParser::request_maze_from_user();
-
         // Lese die Startpositon des Spielers aus dem eingelesenen Labyrinth aus
-        vector<int> player_start_position = maze.get_player_start_position();
+        PositionVector player_start_position = this->maze.get_player_start_position();
 
         // Überschreibe den Spieler mit der gegebenen Startposition
-        this->player = Player(player_start_position[1], player_start_position[0]);
+        this->player = Player(player_start_position);
     }
 
-    PositionVector Game::handle_user_input(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);
@@ -79,18 +76,18 @@ namespace game // Namespace = Scope with name and no features
         while (true)
         {
             // Kontrolliere, ob der Spieler an einem Geist gestorben ist
-            if (maze.was_player_killed_by_ghost(player))
+            if (this->maze.was_player_killed_by_ghost(player))
             {
                 cout << "Sie haben einen Geist getroffen! Game Over!\n";
                 break;
             }
 
             // Zeige dem Spieler das Spielfeld
-            maze.render(player);
+            this->maze.render(player);
 
 
             // Kontrolliere, ob der Spieler schon das Ziel erreicht hat
-            if (maze.is_player_at_goal(player))
+            if (this->maze.is_player_at_goal(player))
             {
                 // Ziel erreicht! Herzlichen Glückwunsch!
                 cout << "Ziel erreicht! Herzlichen Glueckwunsch!\n";
@@ -107,13 +104,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
             {
-                maze = player.move(maze, movement_vector);
+                player.move(this->maze, movement_vector);
             }
             catch (MovementNotPossible& err)
             {
diff --git a/Game.h b/Game.h
index d43fdb8..896bc25 100644
--- a/Game.h
+++ b/Game.h
@@ -17,7 +17,7 @@ namespace game
         Player player;
 
     public:
-        Game();
+        Game(Maze& maze);
 
         /// Bearbeite die Eingabe des Spielers
         /// @param input Die Eingabe des Nutzers
diff --git a/Maze.cpp b/Maze.cpp
index 9df787f..e659e3a 100644
--- a/Maze.cpp
+++ b/Maze.cpp
@@ -4,14 +4,18 @@
 
 #include "Maze.h"
 #include "Player.h"
+#include "Exceptions/MalformedMaze.h"
+
+using game_exceptions::MalformedMaze;
 
 namespace game
 {
     Maze::Maze(const vector<vector<char>> play_field, const vector<int> player_start_position):
         field(play_field),
-        player_start_position(player_start_position)
+        player_start_position(PositionVector{player_start_position[1], player_start_position[0]})
     {
-        // Wir brauchen keinen Inhalt in diesem Konstruktor, da wir nur die Variablen initialisieren müssen
+        if (!this->is_pos_free(this->player_start_position, false))
+            throw MalformedMaze("Player oob");
     }
 
     bool Maze::was_player_killed_by_ghost(Player player) const
@@ -67,7 +71,7 @@ namespace game
         this->field[pos.y][pos.x] = target;
     }
 
-    vector<int> Maze::get_player_start_position()
+    PositionVector Maze::get_player_start_position() const
     {
         // Gebe die Startposition des Spielers zurück
         return this->player_start_position;
diff --git a/Maze.h b/Maze.h
index 48159ba..0d7e268 100644
--- a/Maze.h
+++ b/Maze.h
@@ -19,7 +19,7 @@ namespace game
     /// Das Spielfeld
     vector<vector<char>> field;
     /// Die Startposition des Spielers
-    vector<int> player_start_position;
+    PositionVector player_start_position;
 
   public:
     /// Das Spielfeld
@@ -57,7 +57,7 @@ namespace game
 
     /// Kriege die Startposition des Spielers
     /// @return Die Startposition des Spielers
-    vector<int> get_player_start_position();
+    PositionVector get_player_start_position() const;
   };
 } // game
 
diff --git a/MazeParser.cpp b/MazeParser.cpp
index 0499265..54611c2 100644
--- a/MazeParser.cpp
+++ b/MazeParser.cpp
@@ -38,7 +38,7 @@ namespace game
         return list;
     }
 
-    bool MazeParser::is_valid_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)
@@ -49,8 +49,6 @@ namespace game
         return false;
     }
 
-
-
     Maze MazeParser::request_maze_from_user()
     {
         // Lese aus, wie groß das Labyrinth sein soll
@@ -81,7 +79,7 @@ namespace game
                     throw ExitGame("Schoenen Tag noch!");
 
                 // Kontrolliere, ob das Element in einem Labyrinth vorkommen darf
-                if (!is_valid_maze_element(input))
+                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
diff --git a/MazeParser.h b/MazeParser.h
index 99a3d70..239aa58 100644
--- a/MazeParser.h
+++ b/MazeParser.h
@@ -33,7 +33,7 @@ namespace game
         /// 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);
+        static bool validate_maze_element(char target);
 
     public:
         /// Lese ein Labyrinth aus der Konsole
diff --git a/Player.cpp b/Player.cpp
index 50c4994..c7dc8e2 100644
--- a/Player.cpp
+++ b/Player.cpp
@@ -16,6 +16,10 @@ namespace game
     // 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)
+  {
+  }
+
   PositionVector Player::get_pos() const
   {
     // Gebe die aktuelle Position des Spielers zurück
@@ -29,7 +33,7 @@ namespace game
   }
 
 
-  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,
diff --git a/Player.h b/Player.h
index 8a85de3..62911b4 100644
--- a/Player.h
+++ b/Player.h
@@ -24,6 +24,10 @@ namespace game
         /// @param target_y Die Startposition des Spielers (Y-Koordinate)
         Player(int target_x, int target_y);
 
+        /// Ein Spieler
+        /// @param pos Die Startposition des Spielers
+        explicit Player(PositionVector pos);
+
         /// Kriege die Position des Spielers
         /// @return Die Position des Spielers
         PositionVector get_pos() const;
@@ -36,7 +40,7 @@ namespace game
         /// @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, PositionVector move_vector);
 
         /// Check, if a player has at least one key
         /// @return If the player as an available key
diff --git a/main.cpp b/main.cpp
index 02729ff..7fde21c 100644
--- a/main.cpp
+++ b/main.cpp
@@ -25,17 +25,19 @@ int main()
 {
     try
     {
-        // Erstelle eine Variable, in der wir das eingelesene Labyrinth speichern
-        Game game = Game();
+        // 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& _)
+    catch (MalformedMaze& err)
     {
         // Das Labyrinth einlesen hat nicht geklappt. Gebe Fehlermeldung aus und beende das Programm.
         cout << "Fehler beim Einlesen des Labyrinths.\n";
-        return 0;
     } catch (ExitGame& _)
     {
         cout << "Schoenen Tag noch!" << "\n";