6

.idea/encodings.xml

@@ -20,5 +20,11 @@
     <file url="file://$PROJECT_DIR$/src/nogard/schritt5/Gegenstand.java" charset="windows-1252" />
     <file url="file://$PROJECT_DIR$/src/nogard/schritt5/GegenstandNichtVorhandenException.java" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/src/nogard/schritt5/Spieler.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt6b/BefehlFactory.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt6b/BefehlFactory.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt6b/Gegenstand.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt6b/Gegenstand.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt6b/Spieler.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt6b/Spieler.java" charset="windows-1252" />
   </component>
 </project>

src/nogard/schritt6/Bereich.java

@@ -0,0 +1,102 @@
+package nogard.schritt6;
+
+import nogard.schritt6.Gegenstand;
+import nogard.schritt6.GegenstandNichtVorhandenException;
+import nogard.schritt6.Richtungen;
+import nogard.schritt6.exceptions.GegenstandNichtVorhandenException;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+/**
+ * Diese Klasse modelliert Bereiche.Ein Bereich kann ein Gebiet, ein Haus, ein Raum etc. sein.
+ * 
+ * Jeder Bereich ist mit anderen Bereichen <20>ber Ausg<73>nge verbunden. M<>gliche Ausg<73>nge liegen im Norden, Osten, S<>den und Westen.
+ * 
+ * F<>r jeden Ausgang h<>lt ein Bereich eine Referenz auf den benachbarten Bereich parat.
+ */
+public class Bereich {
+
+	private final String beschreibung;
+	private final Map<Richtungen, Bereich> nachbarn;
+	private final LinkedList<Gegenstand> gegenstaende;
+	/**
+     * Konstruktor.
+     * @param beschreibung	Die Beschreibung des Areals.
+     */
+    public Bereich(String beschreibung) {
+        this.beschreibung = beschreibung;
+        nachbarn = new HashMap<>();
+		gegenstaende = new LinkedList<>();
+
+		for (Richtungen r: Richtungen.values()) {
+			nachbarn.put(r, null);
+		}
+    }
+
+    /**
+     * Liefert die Beschreibung des Bereichs.
+     * @return	Die Beschreibung des Bereichs.
+     */
+    public String getBeschreibung() {
+        return beschreibung;
+    }
+
+	/**
+	 * Setzt den Nachbarn des Bereiches.
+	 * @param r Die Richtung / Ort des Nachbarbereichs.
+	 * @param n Der Nachbar welcher Relativ zu diesem Objekt liegt.
+	 */
+	public void setNachbar(Richtungen r, Bereich n) {
+		nachbarn.put(r, n);
+	}
+
+	/**
+	 *
+	 * @param richtung Die Richtung in welcher ein Nachbar liegen könnte.
+	 * @return Den Nachbarn in der angegebenen Richtung, oder NULL wenn in der Richtung kein Bereich liegt.
+	 */
+	public Bereich getNachbar(Richtungen richtung) {
+		return nachbarn.get(richtung);
+	}
+
+	public void platziereGegenstand(Gegenstand g) {
+		gegenstaende.add(g);
+	}
+
+	public void entferneGegenstand(Gegenstand g) throws GegenstandNichtVorhandenException {
+		boolean success = gegenstaende.remove(g);
+		if (!success) {
+			throw new GegenstandNichtVorhandenException(g);
+		}
+	}
+
+	public Gegenstand sucheGegenstand(String name) throws GegenstandNichtVorhandenException {
+		for (Gegenstand g: gegenstaende) {
+			if (g.getName().equalsIgnoreCase(name)) {
+				return g;
+			}
+		}
+
+		throw new GegenstandNichtVorhandenException(name);
+	}
+
+	public String getInfo() {
+		StringBuilder sb = new StringBuilder();
+		sb.append("\n\tDu bist im Bereich ");
+		sb.append(getBeschreibung());
+		sb.append("\n\tDeine Nachbarn sind:");
+		for (Map.Entry<Richtungen, Bereich> paar: nachbarn.entrySet()) {
+			if (paar.getValue() != null) {
+				sb.append("\n\t").append(paar.getKey().name());
+			}
+		}
+		sb.append("\nGegenstaende:");
+		for (Gegenstand g: gegenstaende) {
+			sb.append("\n\t").append(g.getInfo());
+		}
+
+		return sb.toString();
+	}
+}

src/nogard/schritt6/Gegenstand.java

@@ -0,0 +1,38 @@
+package nogard.schritt6;
+
+public class Gegenstand {
+    private final String name;
+    private final String description;
+    private final double weight_kg;
+
+    public Gegenstand(String name, String description, double weight_kg) {
+        this.name = name;
+        this.description = description;
+        this.weight_kg = weight_kg;
+    }
+
+    public Gegenstand(String name, String description) {
+        this.name = name;
+        this.description = description;
+        this.weight_kg = 0;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public double getWeight_kg() {
+        return weight_kg;
+    }
+
+    public String getInfo() {
+        return "Name: " + name +
+                "\nBeschreibung: " + description +
+                "\nGewicht" + weight_kg +
+                "\n";
+    }
+}

src/nogard/schritt6/Nahrung.java

@@ -0,0 +1,21 @@
+package nogard.schritt6;
+
+import nogard.schritt6.Gegenstand;
+
+public class Nahrung extends Gegenstand {
+    private final int nutrients;
+
+    public Nahrung(String name, String description, int nutrients) {
+        super(name, description);
+        this.nutrients = nutrients;
+    }
+
+    public int getNutrients() {
+        return nutrients;
+    }
+
+    public String getInfo() {
+        return super.getInfo() +
+                getNutrients();
+    }
+}

src/nogard/schritt6/Program.java

@@ -0,0 +1,11 @@
+package nogard.schritt6;
+
+import nogard.schritt6.Spiel;
+
+public class Program {
+
+	public static void main(String[] args) {
+		new Spiel().spielen();
+	}
+
+}

src/nogard/schritt6/Richtungen.java

@@ -0,0 +1,5 @@
+package nogard.schritt6;
+
+public enum Richtungen {
+    NORTH, EAST, SOUTH, WEST, UP, DOWN
+}

src/nogard/schritt6/Spiel.java

@@ -0,0 +1,109 @@
+package nogard.schritt6;
+
+import nogard.schritt6b.*;
+import nogard.schritt6b.commands.CommandFactory;
+import nogard.schritt6b.commands.CommandQuit;
+import nogard.schritt6b.commands.ICommand;
+import nogard.schritt6b.exceptions.*;
+
+import java.util.Scanner;
+
+/**
+ *
+ *  Dies ist die Hauptklasse der Anwendung "Die Welt von Nogard".
+ *  
+ *  "Die Welt von Nogard" ist ein sehr einfaches, textbasiertes Adventure-Game, in dem sich ein Spieler durch Nogard bewegen kann. 
+ *  
+ *  Das Spiel sollte auf jeden Fall ausgebaut werden, damit es interessanter wird!
+ * 
+ *  Zum Spielen muss an einer Instanz dieser Klasse die Methode "spielen()" aufgerufen werden.
+ * 
+ *  Diese Klasse erzeugt und initialisiert alle Objekte der Anwendung: 
+ *  - Sie legt alle Bereiche an. Anschlie<69>end startet das Spiel. 
+ *  - Sie wertet die Befehle aus und sorgt f<>r ihre Ausf<73>hrung.
+ */
+public class Spiel {
+	private Spieler spieler;
+
+	public Spiel() {
+		erzeugeDorf();
+	}
+    /**
+     * Die Hauptmethode zum Spielen. 
+     * L<>uft bis zum Ende des Spiels in einer Schleife.
+     */
+    public void spielen() {
+		ausgebenStartText();
+
+		// Befehle einlesen und auswerten.
+        Scanner scannerZeile = new Scanner(System.in);
+
+		boolean end = false;
+        while (! end) {
+            // Eingabeaufforderung anzeigen.
+            System.out.print("> ");
+			String input = scannerZeile.nextLine();
+			try {
+				ICommand command = CommandFactory.createCommand(spieler, input);
+				end = command instanceof CommandQuit;
+				command.execute();
+			} catch (BefehlUnbekanntException e) {
+				System.out.println(e.getMessage());
+			}
+		}
+        
+        // Endbildschirm ausgeben.
+		ausgebenEndText();
+	}
+
+	private void ausgebenEndText() {
+		System.out.println("Danke für dieses Spiel. Auf Wiedersehen.");
+	}
+
+	private void ausgebenStartText() {
+		// Begr<67><72>ungsbildschirm ausgeben.
+		System.out.println("Willkommen in Nogard!");
+		System.out.println("Entdecke die Welt von Nogard. Doch Vorsicht, überall lauern Gefahren!");
+		System.out.println("Wenn du Hilfe benötigst, tippe 'help'.");
+		System.out.println();
+		System.out.println(spieler.getInfo());
+		System.out.println(spieler.getBereich().getInfo());
+	}
+
+	private void erzeugeDorf() {
+		// Die Bereiche erzeugen.
+		Bereich friedhof = new Bereich("auf einem Friedhof, umgeben von dunklen Tannen");
+		Bereich wald = new Bereich("im dunklen Stadtwald von Nogard");
+		Bereich taverne = new Bereich("in der Taverne, mit zwielichtigen Gestalten an der Theke");
+		Bereich hexenhaus = new Bereich("im finsteren Hexenhaus");
+		Bereich rathaus = new Bereich("im Rathaus von Nogard");
+		Bereich weinkeller = new Bereich("Weinkeller der Taverne");
+
+		// Die Nachbarschaften festlegen.
+		taverne.setNachbar(Richtungen.NORTH, rathaus);
+		taverne.setNachbar(Richtungen.WEST, wald);
+		taverne.setNachbar(Richtungen.DOWN, weinkeller);
+		weinkeller.setNachbar(Richtungen.UP, taverne);
+		wald.setNachbar(Richtungen.NORTH, friedhof);
+		friedhof.setNachbar(Richtungen.SOUTH, wald);
+		friedhof.setNachbar(Richtungen.EAST, hexenhaus);
+		hexenhaus.setNachbar(Richtungen.WEST, friedhof);
+
+		// Gegenstände Platzieren
+		hexenhaus.platziereGegenstand(new Gegenstand("Krug", "mit fauligem Krötenwasser", 5.0));
+		hexenhaus.platziereGegenstand(new Nahrung("Froschschenkel", "mit ranziger Knoblauchbutter", 700));
+
+		// Erzeugen des Spielers
+		Scanner scannerZeile = new Scanner(System.in);
+		System.out.println("Spieler Erstellung\n");
+		System.out.println("Name > ");
+		String name = scannerZeile.nextLine();
+		System.out.println("Traglast > ");
+		float traglast = scannerZeile.nextFloat();
+		System.out.println("Fitness > ");
+		int fitness = scannerZeile.nextInt();
+
+		spieler = new Spieler(name, traglast, fitness, hexenhaus);
+	}
+
+}

src/nogard/schritt6/Spieler.java

@@ -0,0 +1,136 @@
+package nogard.schritt6;
+
+import nogard.schritt6.*;
+import nogard.schritt6.Bereich;
+import nogard.schritt6.Nahrung;
+import nogard.schritt6.exceptions.GegenstandNichtVorhandenException;
+import nogard.schritt6.exceptions.GegenstandZuSchwerException;
+import nogard.schritt6.exceptions.SpielerSattException;
+import nogard.schritt6.exceptions.SpielerZuSchwachException;
+
+import java.util.LinkedList;
+
+public class Spieler {
+    private static final int FITNESS_max = 5000;
+    private static final int VERBRAUCH_GEHEN = 500;
+
+    private final String name;
+    private final float max_traglast;
+    private int fitness;
+    private final LinkedList<Gegenstand> items;
+    private nogard.schritt6.Bereich bereich;
+
+    public Spieler(String name, float max_traglast, int fitness, nogard.schritt6.Bereich bereich) {
+        this.name = name;
+        this.max_traglast = max_traglast;
+        this.fitness = fitness;
+        items = new LinkedList<>();
+        this.bereich = bereich;
+    }
+
+    /**
+     * Berechnet das Gesamtgewicht aller items des Spielers.
+     * @return Die Auslastung des Spielers.
+     */
+    public float getTraglast() {
+        float total_weight_kg = 0;
+        for (Gegenstand g: items) {
+            total_weight_kg += g.getWeight_kg();
+        }
+        return total_weight_kg;
+    }
+
+    /**!
+     * Sucht nach einem Gegenstand in dem derzeitigen Bereich.
+     * @param name Der Name des aufzunehmenden Gegenstands.
+     * @throws GegenstandZuSchwerException wenn das Aufnehmen des Gegenstands die Traglast überschreitet.
+     * @throws GegenstandNichtVorhandenException wenn der Gegenstand nicht in dem Bereich vorhanden ist
+     */
+    public void aufnehmenGegenstand(String name) throws GegenstandZuSchwerException, GegenstandNichtVorhandenException {
+        Gegenstand g = bereich.sucheGegenstand(name);
+
+        if (getTraglast() + g.getWeight_kg() > max_traglast) {
+            throw new GegenstandZuSchwerException(g);
+        }
+
+        bereich.entferneGegenstand(g);
+        items.add(g);
+    }
+
+    /**
+     * Entfernt den Gegenstand mittels des namens aus dem Inventar des spielers.
+     * @param name Der name des Gegenstands.
+     * @throws GegenstandNichtVorhandenException der Gegenstand befindet sich nicht in dem Inventar des Spielers
+     */
+    public void ablegenGegenstand(String name) throws GegenstandNichtVorhandenException {
+        Gegenstand l_g = null;
+        for (Gegenstand g: items) {
+            if (g.getName().equals(name)) {
+                l_g = g;
+                break;
+            }
+        }
+
+        if (l_g == null) {
+            throw new GegenstandNichtVorhandenException(name);
+        }
+        bereich.platziereGegenstand(l_g);
+        items.remove(l_g);
+    }
+
+    /**
+     * Sucht nach Nahrung mithilfe des Namens in dem Bereich & isst es, wenn sie vorhanden ist
+     * @param name Der Name der Nahrung
+     * @throws GegenstandNichtVorhandenException die Nahrung ist nicht in dem Bereich vorhanden.
+     * @throws SpielerSattException der Spieler kann nicht mehr essen.
+     */
+    public void essen(String name) throws GegenstandNichtVorhandenException, SpielerSattException {
+        Gegenstand g = bereich.sucheGegenstand(name);
+
+        boolean is_nahrung = g instanceof nogard.schritt6b.Nahrung;
+        if (is_nahrung) {
+            nogard.schritt6b.Nahrung n = (Nahrung) g;
+            if (n.getNutrients() + fitness > FITNESS_max) {
+                throw new SpielerSattException("Spieler ist Satt");
+            }
+
+            fitness += n.getNutrients();
+        } else {
+            throw new GegenstandNichtVorhandenException(name);
+        }
+    }
+
+    /**
+     * Wechselt den Bereich
+     * @param b der neue Bereich.
+     * @throws SpielerZuSchwachException der Spieler hat nicht genug Ausdauer für den wechsel.
+     */
+    public void geheInBereich(nogard.schritt6b.Bereich b) throws SpielerZuSchwachException {
+        if (fitness - VERBRAUCH_GEHEN < 0) {
+            throw new SpielerZuSchwachException();
+        }
+
+        fitness -= VERBRAUCH_GEHEN;
+        bereich = b;
+    }
+
+    public Bereich getBereich() {
+        return bereich;
+    }
+
+    public String getInfo() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Spieler:");
+        sb.append("\n\tName: ").append(name);
+        sb.append("\n\tFitness: ").append(fitness);
+        sb.append("\n\tTraglast: ").append(getTraglast()).append("/").append(max_traglast);
+        sb.append("\n\tItems: [");
+        for (Gegenstand g: items) {
+            sb.append(g.getName()).append(", ");
+        }
+        sb.append("]");
+        sb.append("\n\tBereich: ").append(bereich.getBeschreibung());
+
+        return sb.toString();
+    }
+}

src/nogard/schritt6/commands/CommandEat.java

@@ -0,0 +1,23 @@
+package nogard.schritt6.commands;
+import nogard.schritt6b.Spieler;
+import nogard.schritt6b.exceptions.GegenstandNichtVorhandenException;
+import nogard.schritt6b.exceptions.SpielerSattException;
+
+public class CommandEat implements ICommand {
+    private Spieler spieler;
+    private String nahrung;
+
+    public CommandEat(Spieler spieler, String nahrung) {
+        this.spieler = spieler;
+        this.nahrung = nahrung;
+    }
+
+    @Override
+    public void execute() {
+        try {
+            spieler.essen(nahrung);
+        } catch (GegenstandNichtVorhandenException | SpielerSattException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+}

src/nogard/schritt6/commands/CommandFactory.java

@@ -0,0 +1,21 @@
+package nogard.schritt6.commands;
+
+import nogard.schritt6b.Richtungen;
+import nogard.schritt6b.Spieler;
+import nogard.schritt6b.exceptions.BefehlUnbekanntException;
+
+public class CommandFactory {
+    public static ICommand createCommand(Spieler spieler, String input) throws BefehlUnbekanntException {
+        String[] cmd_data = input.split(" ");
+
+        return switch (cmd_data[0]) {
+            case "go" -> new CommandGo(spieler, Richtungen.valueOf(cmd_data[1].toUpperCase()));
+            case "take" -> new CommandTake(spieler, cmd_data[1]);
+            case "put" -> new CommandPut(spieler, cmd_data[1]);
+            case "info" -> new CommandInfo(spieler);
+            case "quit" -> new CommandQuit();
+            case "eat" -> new CommandEat(spieler, cmd_data[1]);
+            default -> throw new BefehlUnbekanntException(input);
+        };
+    }
+}

src/nogard/schritt6/commands/CommandGo.java

@@ -0,0 +1,24 @@
+package nogard.schritt6.commands;
+
+import nogard.schritt6b.Richtungen;
+import nogard.schritt6b.Spieler;
+import nogard.schritt6b.exceptions.SpielerZuSchwachException;
+
+public class CommandGo implements ICommand {
+    private Spieler spieler;
+    private Richtungen richtung;
+
+    public CommandGo(Spieler spieler, Richtungen richtung) {
+        this.spieler = spieler;
+        this.richtung = richtung;
+    }
+
+    @Override
+    public void execute() {
+        try {
+            spieler.geheInBereich(spieler.getBereich().getNachbar(richtung));
+        } catch (SpielerZuSchwachException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+}

src/nogard/schritt6/commands/CommandHelp.java

@@ -0,0 +1,8 @@
+package nogard.schritt6.commands;
+
+public class CommandHelp implements ICommand {
+    @Override
+    public void execute() {
+        System.out.println("AAAAAAAAAAAAAa");
+    }
+}

src/nogard/schritt6/commands/CommandInfo.java

@@ -0,0 +1,16 @@
+package nogard.schritt6.commands;
+
+import nogard.schritt6b.Spieler;
+
+public class CommandInfo implements ICommand {
+    private final Spieler spieler;
+
+    public CommandInfo(Spieler spieler) {
+        this.spieler = spieler;
+    }
+
+    @Override
+    public void execute() {
+        System.out.println(spieler.getInfo());
+    }
+}

src/nogard/schritt6/commands/CommandPut.java

@@ -0,0 +1,23 @@
+package nogard.schritt6.commands;
+
+import nogard.schritt6b.Spieler;
+import nogard.schritt6b.exceptions.GegenstandNichtVorhandenException;
+
+public class CommandPut implements ICommand {
+    private Spieler spieler;
+    private String gegenstand;
+
+    public CommandPut(Spieler spieler, String gegenstand) {
+        this.spieler = spieler;
+        this.gegenstand = gegenstand;
+    }
+
+    @Override
+    public void execute() {
+        try {
+            spieler.ablegenGegenstand(gegenstand);
+        } catch (GegenstandNichtVorhandenException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+}

src/nogard/schritt6/commands/CommandQuit.java

@@ -0,0 +1,8 @@
+package nogard.schritt6.commands;
+
+public class CommandQuit implements ICommand {
+    @Override
+    public void execute() {
+
+    }
+}

src/nogard/schritt6/commands/CommandTake.java

@@ -0,0 +1,24 @@
+package nogard.schritt6.commands;
+
+import nogard.schritt6b.Spieler;
+import nogard.schritt6b.exceptions.GegenstandNichtVorhandenException;
+import nogard.schritt6b.exceptions.GegenstandZuSchwerException;
+
+public class CommandTake implements ICommand {
+    private Spieler spieler;
+    private String gegenstand;
+
+    public CommandTake(Spieler spieler, String gegenstand) {
+        this.spieler = spieler;
+        this.gegenstand = gegenstand;
+    }
+
+    @Override
+    public void execute() {
+        try {
+            spieler.aufnehmenGegenstand(gegenstand);
+        } catch (GegenstandNichtVorhandenException | GegenstandZuSchwerException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+}

src/nogard/schritt6/commands/ICommand.java

@@ -0,0 +1,5 @@
+package nogard.schritt6.commands;
+
+public interface ICommand {
+    void execute();
+}

src/nogard/schritt6/exceptions/BefehlUnbekanntException.java

@@ -0,0 +1,14 @@
+package nogard.schritt6.exceptions;
+
+public class BefehlUnbekanntException extends Exception {
+    private final String befehl;
+
+    public BefehlUnbekanntException(String befehl) {
+        this.befehl = befehl;
+    }
+
+    @Override
+    public String getMessage() {
+        return befehl;
+    }
+}

src/nogard/schritt6/exceptions/GegenstandNichtVorhandenException.java

@@ -0,0 +1,22 @@
+package nogard.schritt6.exceptions;
+
+import nogard.schritt6b.Gegenstand;
+
+public class GegenstandNichtVorhandenException extends Exception {
+    private final String text;
+    public GegenstandNichtVorhandenException(Gegenstand g) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(g.getInfo());
+        sb.append("Ist nicht in dem Bereich vorhanden.");
+        text = sb.toString();
+    }
+
+    public GegenstandNichtVorhandenException(String text) {
+        this.text = text;
+    }
+
+    @Override
+    public String getMessage() {
+        return text;
+    }
+}

src/nogard/schritt6/exceptions/GegenstandZuSchwerException.java

@@ -0,0 +1,20 @@
+package nogard.schritt6.exceptions;
+
+import nogard.schritt6b.Gegenstand;
+
+public class GegenstandZuSchwerException extends Exception {
+    private final String text;
+
+    public GegenstandZuSchwerException(Gegenstand g) {
+        text = "Ist zu schwer: " + g.getDescription();
+    }
+
+    public GegenstandZuSchwerException(String text) {
+        this.text = text;
+    }
+
+    @Override
+    public String getMessage() {
+        return text;
+    }
+}

src/nogard/schritt6/exceptions/SpielerSattException.java

@@ -0,0 +1,14 @@
+package nogard.schritt6.exceptions;
+
+public class SpielerSattException extends Exception {
+    private final String text;
+
+    public SpielerSattException(String text) {
+        this.text = text;
+    }
+
+    @Override
+    public String getMessage() {
+        return text;
+    }
+}

src/nogard/schritt6/exceptions/SpielerZuSchwachException.java

@@ -0,0 +1,18 @@
+package nogard.schritt6.exceptions;
+
+public class SpielerZuSchwachException extends Exception {
+    private String text;
+
+    public SpielerZuSchwachException() {
+        text = "Der Spieler ist zu schwach";
+    }
+
+    public SpielerZuSchwachException(String text) {
+        this.text = text;
+    }
+
+    @Override
+    public String getMessage() {
+        return text;
+    }
+}

src/nogard/schritt6b/Befehl.java

@@ -0,0 +1,51 @@
+package nogard.schritt6b;
+
+/**
+ * Objekte dieser Klasse halten Informationen <20>ber Befehle, die der Benutzer eingegeben hat. 
+ * 
+ * Ein Befehl besteht momentan aus zwei Zeichenketten: 
+ * - einer ersten Zeichenkette, die das Schl<68>sselwort des Befehls angibt und 
+ * - einer zweiten Zeichenkette, die einen Zusatz zum Befehl enth<74>lt.
+ * 
+ * Beim Befehl "go north" sind die beiden Zeichenketten des Befehls 
+ * - "go" und 
+ * - "north".
+ * 
+ * Wenn der Befehl nur aus einem Schl<68>sselwort besteht, dann ist das zweite Wort 'null'.
+ */
+public class Befehl {
+	
+    private String befehlsWort;
+    private String befehlsZusatz;
+
+    /**
+     * Konstruktor.
+     * @param befehlsWort 		Das Schl<68>sselwort des Befehls. 
+     * 							Sollte 'null' sein, wenn dieser Befehl als nicht vom Spiel erkannt gekennzeichnet werden soll.
+     * @param befehlsZusatz		Der Zusatz des Befehls.
+     * 							Sollte 'null' sein, wenn der Befehl nur aus einem Schl<68>sselwort besteht.
+     */
+    public Befehl(String befehlsWort, String befehlsZusatz) {
+        this.befehlsWort = befehlsWort;
+        this.befehlsZusatz = befehlsZusatz;
+    }
+
+    /**
+     * Liefert das Schl<68>sselwort des Befehls.
+     * @return Das Schl<68>sselwort des Befehls.
+     */
+    public String getBefehlsWort() {
+        return befehlsWort;
+    }
+
+    /**
+     * Liefert den Zusatz zum Befehl.
+     * Wenn es keinen Befehlszusatz gibt, ist das Ergebnis 'null'. 
+     * @return Den Zusatz zum Befehl.
+     */
+    public String getBefehlsZusatz() {
+        return befehlsZusatz;
+    }
+    
+}
+

src/nogard/schritt6b/BefehlFactory.java

@@ -0,0 +1,61 @@
+package nogard.schritt6b;
+
+/**
+ * Diese Klasse erzeugt Instanzen der Klasse Befehl.
+ * 
+ * Kann keine Instanz der Klasse Befehl erzeugt werden, so reagiert die Klasse mit einer entsprechenden Fehlermeldung.
+ * 
+ * Besteht ein Befehl nur aus seinem Schl<68>sselwort, so ist der Zusatz des Befehls 'null'.
+ */
+public class BefehlFactory {
+	/**
+	 * Erstellt eine neue Instanz eines Befehls auf Basis einer Benutzereingabe.
+	 * @param input	Die Benutzereingabe.
+	 * @return		Der erstellte Befehl.
+	 * @throws BefehlUnbekanntException	Wird geworfen, wenn keine Instanz eines Befehls erzeugt werden kann. Gr<47>nde k<>nnen sein:
+	 * 									- Kein Befehl eingegeben.
+	 * 									- Unbekannter Befehl eingegeben.
+	 * 									- Unbekannte oder nicht eingegebene Richtung beim Befehl "go".
+	 */
+	public static Befehl createBefehl(String input) throws BefehlUnbekanntException {
+		// Abbruch bei fehlender Eingabe.
+        if(input == null || input.trim().equals("")) {
+            throw new BefehlUnbekanntException("Du hast keinen Befehl eingegeben.");
+        }
+        // Befehl aufsplitten in die einzelnen Befehlsteile
+		String[] befehlArray = input.trim().split(" ");
+        // Auswerten des Befehlsworts
+        Befehl befehl = null;
+        String befehlWort = befehlArray[0].trim().toLowerCase();
+        switch (befehlWort) {
+			case "go":
+	        	if (befehlArray.length >= 2) {
+		        	String richtung = befehlArray[1].trim().toLowerCase();
+		        	// Pr<50>fen der angegebenen Richtung per Schleife <20>ber Enum aller Richtungen
+		        	for (Richtungen r : Richtungen.values()) {
+						if (r.name().equalsIgnoreCase(richtung)) {
+							befehl = new Befehl(befehlWort, richtung);
+							break;
+						}
+		        	}
+		        	if (befehl == null) {
+		        		throw new BefehlUnbekanntException("Gib eine korrekte Richtung an.");
+		        	}
+	        	}
+	        	else {
+	        		throw new BefehlUnbekanntException("Erg<EFBFBD>nze deinen Befehl um die Richtung, in die du dich bewegen m<>chtest.");
+	        	}
+				break;
+			case "help":
+	        	befehl = new Befehl("help", null);
+				break;
+			case "quit":
+	        	befehl = new Befehl("quit", null);
+				break;
+			default:
+        		throw new BefehlUnbekanntException("Ich wei<65> nicht, was du meinst ...");
+		}
+		return befehl;
+	}
+	
+}

src/nogard/schritt6b/BefehlUnbekanntException.java

@@ -0,0 +1,26 @@
+package nogard.schritt6b;
+
+/**
+ * Die Exceptionklasse, die geworfen wird, wenn ein Befehl unbekannt ist.
+ */
+public class BefehlUnbekanntException extends Exception {
+	
+	private String meldung;
+	
+	/**
+	 * Konstruktor.
+	 * @param meldung	Die Fehlermeldung.
+	 */
+	public BefehlUnbekanntException(String meldung) {
+		this.meldung = meldung;
+	}
+
+	/* (non-Javadoc)
+	 * @see java.lang.Throwable#getMessage()
+	 */
+	@Override
+	public String getMessage() {
+		return meldung;
+	}
+
+}

src/nogard/schritt6b/Bereich.java

@@ -0,0 +1,120 @@
+package nogard.schritt6b;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Diese Klasse modelliert Bereiche. Ein Bereich kann ein Gebiet, ein Haus, ein Raum etc. sein.
+ * 
+ * Jeder Bereich ist mit anderen Bereichen <20>ber Ausg<73>nge verbunden. M<>gliche Ausg<73>nge liegen im Norden, Osten, S<>den, Westen, oben und unten.
+ * 
+ * F<>r jeden Ausgang h<>lt ein Bereich eine Referenz auf den benachbarten Bereich parat.
+ */
+public class Bereich {
+	
+    private String beschreibung;
+    private Map<Richtungen, nogard.schritt6b.Bereich> nachbarn;
+    private List<Gegenstand> gegenstaende;
+
+    /**
+     * Konstruktor.
+     * @param beschreibung	Die Beschreibung des Areals.
+     */
+    public Bereich(String beschreibung) {
+        this.beschreibung = beschreibung;
+        nachbarn = new HashMap<>();
+        for (Richtungen richtung : Richtungen.values()) {
+			nachbarn.put(richtung, null);
+		}
+        gegenstaende = new LinkedList<>();
+    }
+
+    /**
+     * Liefert die Beschreibung des Bereichs.
+     * @return	Die Beschreibung des Bereichs.
+     */
+    public String getBeschreibung() {
+        return beschreibung;
+    }
+
+    /**
+     * Liefert einen benachbarten Bereich.
+     * @param richtung	Die Richtung des gew<65>nschten benachbarten Bereichs.
+     * @return			Der gew<65>nschte benachbarte Bereich.
+     */
+    public nogard.schritt6b.Bereich getNachbar(Richtungen richtung) {
+    	return nachbarn.get(richtung);
+    }
+
+	/**
+	 * Gibt die Informationen <20>ber den Bereich zur<75>ck.
+	 * @return	Die Informationen <20>ber den Bereich.
+	 */
+	public String getInfo() {
+		StringBuilder info = new StringBuilder();
+		info.append("\nDu befindest dich " + beschreibung + ".");
+		// Alle gegenst<73>nde ausgeben, wenn vorhanden.
+		if (gegenstaende.size() > 0) {
+			info.append("\nHier befinden sich die folgenden Gegenst<73>nde:");
+			for (Gegenstand gegenstand : gegenstaende) {
+				info.append("\n\t" + gegenstand.getInfo());
+			}
+		}
+        info.append("\nDu kannst gehen nach:");
+        // Alle nichtleeren Bereiche ausgeben.
+        for (Map.Entry<Richtungen, nogard.schritt6b.Bereich> paar : nachbarn.entrySet()) {
+			if (paar.getValue() != null) {
+				info.append("\n\t" + paar.getKey().name().toLowerCase());
+			}
+		}
+        return info.toString();
+	}
+
+    /**
+     * F<>gt einen benachbarten Bereich hinzu.
+     * Befindet sich bereits ein benachbarter Bereich an dieser Stelle, so wird er durch den neuen ersetzt.
+     * @param richtung	Die Richtung, in der sich der hinzuzuf<75>gende benachbarte Bereich befindet.
+     * @param nachbar	Der hinzuzuf<75>gende benachbarte Bereich.
+     */
+    public void setNachbar(Richtungen richtung, nogard.schritt6b.Bereich nachbar) {
+    	nachbarn.put(richtung, nachbar);
+    }
+
+    /**
+     * F<>gt einen neuen Gegenstand dem Bereich hinzu.
+     * @param gegenstand	Der hinzuzuf<75>gende Gegenstand.
+     */
+	public void platzierenGegenstand(Gegenstand gegenstand) {
+		gegenstaende.add(gegenstand);
+	}
+
+	/**
+	 * Entfernt einen Gegenstand aus dem Bereich.
+	 * @param nameGegenstand	Der zu entfernende Gegenstand.
+	 * @throws GegenstandNichtVorhandenException	Wird geworfen, wenn der zu entfernende Gegenstand nicht vorhanden ist.
+	 */
+	public void entfernenGegenstand(Gegenstand gegenstand) throws GegenstandNichtVorhandenException {
+		boolean entfernt = gegenstaende.remove(gegenstand);
+		if (entfernt == false) {
+			throw new GegenstandNichtVorhandenException("In diesem Bereich befindet sich leider kein Gegenstand mit dem Namen " + gegenstand.getName() + ".");
+		}
+	}
+	
+	/**
+	 * Sucht einen Gegenstand im Bereich.
+	 * @param nameGegenstand	Der Name des zu suchenden Gegenstandes.
+	 * @return					Der gesuchte Gegenstand.
+	 * @throws GegenstandNichtVorhandenException	Wird geworfen, wenn kein Gegenstand im Bereich den angegebenen Namen hat.
+	 */
+	public Gegenstand suchenGegenstand(String nameGegenstand) throws GegenstandNichtVorhandenException {
+		for (Gegenstand gegenstand : gegenstaende) {
+			if(gegenstand.getName().equalsIgnoreCase(nameGegenstand)) {
+				return gegenstand;
+			}
+		}
+		throw new GegenstandNichtVorhandenException("In diesem Bereich befindet sich leider kein Gegenstand mit dem Namen " + nameGegenstand + ".");
+	}
+
+}

src/nogard/schritt6b/Gegenstand.java

@@ -0,0 +1,56 @@
+package nogard.schritt6b;
+
+/**
+ * Diese Klasse modelliert einen Gegenstand.
+ */
+public class Gegenstand {
+	
+	private String name;
+	private String beschreibung;
+	private double gewicht;
+	
+	/**
+	 * Konstruktor.
+	 * @param name			Der Name des Gegenstandes.
+	 * @param beschreibung	Die Beschreibung des Gegenstandes.
+	 * @param gewicht		Das Gewicht des Gegenstandes in kg.
+	 */
+	public Gegenstand(String name, String beschreibung, double gewicht) {
+		this.name = name;
+		this.beschreibung = beschreibung;
+		this.gewicht = gewicht;
+	}
+
+	/**
+     * Liefert den Namen des Gegenstandes.
+     * @return	Der Name des Gegenstandes.
+	 */
+	public String getName() {
+		return name;
+	}
+
+    /**
+     * Liefert die Beschreibung des Gegenstandes.
+     * @return	Die Beschreibung des Gegenstandes.
+     */
+	public String getBeschreibung() {
+		return beschreibung;
+	}
+
+	/**
+     * Liefert das Gewicht des Gegenstandes in kg.
+     * @return	Das Gewicht des Gegenstandes in kg.
+	 */
+	public double getGewicht() {
+		return gewicht;
+	}
+	
+	/**
+	 * Gibt die Informationen <20>ber den Gegenstand zur<75>ck.
+	 * @return	Die Informationen <20>ber den Gegenstand.
+	 */
+	public String getInfo() {
+		return name + " " + beschreibung + " mit einem Gewicht von " + gewicht + " kg";
+	}
+
+}

src/nogard/schritt6b/GegenstandNichtVorhandenException.java

@@ -0,0 +1,26 @@
+package nogard.schritt6b;
+
+/**
+ * Die Exceptionklasse, die geworfen wird, wenn ein Gegenstand nicht vorhanden ist.
+ */
+public class GegenstandNichtVorhandenException extends Exception {
+	
+	private String meldung;
+	
+	/**
+	 * Konstruktor.
+	 * @param meldung	Die Fehlermeldung.
+	 */
+	public GegenstandNichtVorhandenException(String meldung) {
+		this.meldung = meldung;
+	}
+
+	/* (non-Javadoc)
+	 * @see java.lang.Throwable#getMessage()
+	 */
+	@Override
+	public String getMessage() {
+		return meldung;
+	}
+
+}

src/nogard/schritt6b/GegenstandZuSchwerException.java

@@ -0,0 +1,26 @@
+package nogard.schritt6b;
+
+/**
+ * Die Exceptionklasse, die geworfen wird, wenn ein Gegenstand nicht vorhanden ist.
+ */
+public class GegenstandZuSchwerException extends Exception {
+	
+	private Gegenstand gegenstand;
+	
+	/**
+	 * Konstruktor.
+	 * @param gegenstand	Der Gegenstand.
+	 */
+	public GegenstandZuSchwerException(Gegenstand gegenstand) {
+		this.gegenstand = gegenstand;
+	}
+
+	/* (non-Javadoc)
+	 * @see java.lang.Throwable#getMessage()
+	 */
+	@Override
+	public String getMessage() {
+		return "Der Gegenstand " + gegenstand.getName() + " ist zu schwer.";
+	}
+
+}

src/nogard/schritt6b/Nahrung.java

@@ -0,0 +1,38 @@
+package nogard.schritt6b;
+
+/**
+ * Diese Klasse modelliert Nahrung als einen speziellen Gegenstand.
+ */
+public class Nahrung extends Gegenstand {
+
+	private int naehrwert;
+	
+	/**
+	 * Konstruktor
+	 * @param name			Der Name der Nahrung.
+	 * @param beschreibung	Die Beschreibung der Nahrung.
+	 * @param naehrwert		Der N<>hrwert der Nahrung in Kilokalorien (kcal).
+	 */
+	public Nahrung(String name, String beschreibung, int naehrwert) {
+		super(name, beschreibung, 0);
+		this.naehrwert = naehrwert;
+	}
+	
+	/**
+     * Liefert den N<>hrwert der Nahrung in Kilokalorien (kcal).
+     * @return	Der N<>hrwert der Nahrung in Kilokalorien (kcal).
+	 */
+	public int getNaehrwert() {
+		return naehrwert;
+	}
+	
+	/**
+	 * Gibt die Informationen <20>ber die Nahrung zur<75>ck.
+	 * @return	Die Informationen <20>ber die Nahrung.
+	 */
+	@Override
+	public String getInfo() {
+		return getName() + " " + getBeschreibung() + " mit einem N<>hrwert von " + naehrwert + " kcal";
+	}
+
+}

src/nogard/schritt6b/Program.java

@@ -0,0 +1,9 @@
+package nogard.schritt6b;
+
+public class Program {
+
+	public static void main(String[] args) {
+		new Spiel().spielen();
+	}
+
+}

src/nogard/schritt6b/Richtungen.java

@@ -0,0 +1,10 @@
+package nogard.schritt6b;
+
+/**
+ * Aufz<66>hlung aller m<>glichen Richtungen
+ */
+public enum Richtungen {
+	
+	NORTH, EAST, SOUTH, WEST, UP, DOWN;
+	
+}

src/nogard/schritt6b/Spiel.java

@@ -0,0 +1,199 @@
+package nogard.schritt6b;
+
+import java.util.Scanner;
+
+/**
+ * Dies ist die Hauptklasse der Anwendung "Die Welt von Nogard".
+ * 
+ * "Die Welt von Nogard" ist ein sehr einfaches, textbasiertes Adventure-Game,
+ * in dem sich ein Spieler durch Nogard bewegen kann.
+ * 
+ * Das Spiel sollte auf jeden Fall ausgebaut werden, damit es interessanter
+ * wird!
+ * 
+ * Zum Spielen muss an einer Instanz dieser Klasse die Methode "spielen()"
+ * aufgerufen werden.
+ * 
+ * Diese Klasse erzeugt und initialisiert alle Objekte der Anwendung: 
+ * - Sie legt alle Bereiche an. Anschlie<69>end startet das Spiel. 
+ * - Sie wertet die Befehle aus und sorgt f<>r ihre Ausf<73>hrung.
+ */
+public class Spiel {
+
+	private Spieler spieler;
+
+	/**
+	 * Konstruktor. Erstellt die Spielumgebung.
+	 */
+	public Spiel() {
+		erzeugeDorf();
+	}
+
+	/**
+	 * Die Hauptmethode zum Spielen. L<>uft bis zum Ende des Spiels in einer
+	 * Schleife.
+	 */
+	public void spielen() {
+		// Begr<67><72>ungsbildschirm ausgeben.
+		ausgebenStartText();
+
+		// Befehle einlesen und auswerten.
+		Scanner scannerZeile = new Scanner(System.in);
+		boolean end = false;
+		while (!end) {
+			// Eingabeaufforderung anzeigen.
+			System.out.print("> ");
+			// Befehlszeile lesen.
+			String input = scannerZeile.nextLine();
+			try {
+				// Befehls-Objekt erzeugen.
+				Befehl befehl = BefehlFactory.createBefehl(input);
+				// Befehl ausf<73>hren.
+				end = ausfuehrenBefehl(befehl);
+			} catch (BefehlUnbekanntException e) {
+				System.out.println(e.getMessage());
+			}
+		}
+
+		// Endbildschirm ausgeben.
+		ausgebenEndText();
+	}
+
+	/**
+	 * Erzeugt alle Bereiche und erstellt die Dorfstruktur <20>ber die Festlegung der
+	 * Nachbarschaften. Legt den Startbereich fest.
+	 */
+	private void erzeugeDorf() {
+		// Die Bereiche erzeugen.
+		Bereich friedhof = new Bereich("auf einem Friedhof, umgeben von dunklen Tannen");
+		Bereich hexenhaus = new Bereich("im finsteren Hexenhaus");
+		Bereich rathaus = new Bereich("im Rathaus von Nogard");
+		Bereich taverne = new Bereich("in der Taverne, mit zwielichtigen Gestalten an der Theke");
+		Bereich wald = new Bereich("im dunklen Stadtwald von Nogard");
+		Bereich hoehle = new Bereich("in einer dunklen und feuchten H<>hle");
+		Bereich kraeuterkeller = new Bereich("im Kr<4B>uterkeller der Dorfhexe");
+		Bereich weinkeller = new Bereich("im Weinkeller der Taverne");
+
+		// Die Nachbarschaften festlegen.
+		friedhof.setNachbar(Richtungen.SOUTH, hexenhaus);
+		hexenhaus.setNachbar(Richtungen.NORTH, friedhof);
+		hexenhaus.setNachbar(Richtungen.EAST, rathaus);
+		hexenhaus.setNachbar(Richtungen.SOUTH, wald);
+		hexenhaus.setNachbar(Richtungen.DOWN, kraeuterkeller);
+		rathaus.setNachbar(Richtungen.SOUTH, taverne);
+		rathaus.setNachbar(Richtungen.WEST, hexenhaus);
+		taverne.setNachbar(Richtungen.NORTH, rathaus);
+		taverne.setNachbar(Richtungen.WEST, wald);
+		taverne.setNachbar(Richtungen.DOWN, weinkeller);
+		wald.setNachbar(Richtungen.NORTH, hexenhaus);
+		wald.setNachbar(Richtungen.EAST, taverne);
+		hoehle.setNachbar(Richtungen.NORTH, kraeuterkeller);
+		hoehle.setNachbar(Richtungen.EAST, weinkeller);
+		kraeuterkeller.setNachbar(Richtungen.SOUTH, hoehle);
+		kraeuterkeller.setNachbar(Richtungen.UP, hexenhaus);
+		weinkeller.setNachbar(Richtungen.WEST, hoehle);
+		weinkeller.setNachbar(Richtungen.UP, taverne);
+
+		// Die Gegenst<73>nde in die Bereiche legen.
+		friedhof.platzierenGegenstand(new Gegenstand("Taschentuch", "zum Trocknen deiner Tr<54>nen", 0.1));
+		hexenhaus.platzierenGegenstand(new Gegenstand("Kessel", "zum Kochen der Zaubertr<74>nke", 5.0));
+		hexenhaus.platzierenGegenstand(new Gegenstand("Krug", "mit fauligem Kr<4B>tenwasser", 5.0));
+		hexenhaus.platzierenGegenstand(new Gegenstand("Schale", "mit getrockneten Kr<4B>utern", 2.5));
+		hexenhaus.platzierenGegenstand(new Nahrung("Froschschenkel", "mit ranziger Knoblauchbutter", 700));
+		taverne.platzierenGegenstand(new Nahrung("Bier", "mit luftiger Krone", 500));
+		taverne.platzierenGegenstand(new Nahrung("Wildschweinbraten", "mit Kl<4B><6C>en und klumpiger So<53>e", 1200));
+		taverne.platzierenGegenstand(new Gegenstand("Tisch", "mit verschmierten Essensresten und dicken Kerben", 35.0));
+		taverne.platzierenGegenstand(new Gegenstand("Stuhl", "mit wackligen Beinen und gebrochener Lehne", 2.5));
+		wald.platzierenGegenstand(new Nahrung("Pilze", "leuchtend rot mit wei<65>en Punkten", 200));
+		weinkeller.platzierenGegenstand(new Gegenstand("Fass", "mit lange gelagertem Rotwein", 10.0));
+		hoehle.platzierenGegenstand(new Gegenstand("Spinne", "mit gro<72>en funkelnden Augen und acht haarigen Beinen", 0.2));
+		hoehle.platzierenGegenstand(new Gegenstand("Spinnennetz", "mit Spinne", 0.3));
+		hoehle.platzierenGegenstand(new Gegenstand("Skelett", "ohne Totenkopf", 7.5));
+
+		// Den Spieler festlegen.
+		spieler = new Spieler("Trollo", 20, 3000, wald);
+	}
+
+	/**
+	 * Verarbeitet einen gegebenen Befehl und f<>hrt ihn aus.
+	 *
+	 * @param befehl Der auszuf<75>hrende Befehl.
+	 * @return <true>, wenn der Befehl das Spiel beendet, <false> sonst.
+	 */
+	private boolean ausfuehrenBefehl(Befehl befehl) {
+		switch (befehl.getBefehlsWort()) {
+		case "go":
+			wechselBereich(befehl);
+			return false;
+		case "help":
+			ausgebenHilfeText();
+			return false;
+		case "quit":
+			return true;
+		default:
+			ausgebenFehlerBefehl();
+			return false;
+		}
+	}
+
+	/**
+	 * Wechseln des Bereichs. Wenn es einen benachbarten Bereich gibt, wird dorthin
+	 * gegangen, ansonsten gibt es eine Fehlermeldung.
+	 *
+	 * @param befehl Der auszuf<75>hrende Befehl.
+	 */
+	private void wechselBereich(Befehl befehl) {
+		// Neuen Bereich ermitteln.
+		Richtungen richtung = Richtungen.valueOf(befehl.getBefehlsZusatz().toUpperCase());
+		Bereich neuerBereich = spieler.getBereich().getNachbar(richtung);
+		// Auswertung der gefundenen Bereichs.
+		if (neuerBereich == null) {
+			System.out.println("Dort geht es nicht weiter.");
+		} else {
+			try {
+				spieler.gehenInBereich(neuerBereich);
+			} catch (SpielerZuSchwachException e) {
+				System.out.println(e.getMessage());
+			}
+			System.out.println(spieler.getInfo());
+		}
+	}
+
+	/**
+	 * Gibt einen Begr<67><72>ungstext auf der Konsole aus.
+	 */
+	private void ausgebenStartText() {
+		System.out.println("Willkommen in Nogard!");
+		System.out.println("Entdecke die Welt von Nogard. Doch Vorsicht, <20>berall lauern Gefahren!");
+		System.out.println("Wenn du Hilfe ben<65>tigst, tippe 'help'.");
+		System.out.println();
+		System.out.println(spieler.getInfo());
+	}
+
+	/**
+	 * Gibt einen Text mit Hilfsinformationen auf der Konsole aus.
+	 */
+	private void ausgebenHilfeText() {
+		System.out.println("Du irrst in Nogard herum.");
+		System.out.println("Dir stehen folgende Befehle zur Verf<72>gung:");
+		System.out.println("\tgo");
+		System.out.println("\tquit");
+		System.out.println("\thelp");
+	}
+
+	/**
+	 * Gibt einen Endtext auf der Konsole aus.
+	 */
+	private void ausgebenEndText() {
+		System.out.println("Danke f<>r dieses Spiel. Auf Wiedersehen.");
+	}
+
+	/**
+	 * Gibt einen Fehlertext auf der Konsole aus, wenn der Befehl nicht verstanden
+	 * wird.
+	 */
+	private void ausgebenFehlerBefehl() {
+		System.out.println("Ich wei<65> nicht, was Du meinst ...");
+	}
+
+}

src/nogard/schritt6b/Spieler.java

@@ -0,0 +1,190 @@
+package nogard.schritt6b;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Diese Klasse modelliert einen Spieler.
+ * 
+ * Wechselt der Spieler den Bereich, so kostet das Energie, d.h. sein Fitnesswert sinkt. 
+ * Hat er nicht mehr genug Energie, so kann er den Wechsel nicht durchf<68>hren.
+ * 
+ * Der Spieler kann Nahrung verzehren und damit Energie auftanken. 
+ * Allerdings ist die Aufnahme von Nahrung begrenzt.
+ */
+public class Spieler {
+	
+	private final int VERBRAUCH_GEHEN = 500;
+	private final int FITNESS_Max = 5000;
+	
+	private String name;
+	private double traglastMax;
+	private int fitness;
+	private Bereich bereich;
+	private List<Gegenstand> gegenstaende;
+
+	/**
+	 * Konstruktor.
+	 * @param name			Der Name des Spielers.
+	 * @param traglastMax	Die maximale Traglast, die der Spieler bew<65>ltigen kann.
+	 * @param fitness		Der Fitnesswert des Spielers.
+	 * @param bereich		Der Bereich, in dem sich der Spieler befindet.
+	 */
+	public Spieler(String name, double traglastMax, int fitness, Bereich bereich) {
+		this.name = name;
+		this.traglastMax = traglastMax;
+		this.fitness = fitness;
+		this.bereich = bereich;
+		gegenstaende = new LinkedList<>();
+	}
+
+	/**
+	 * Liefert den Namen des Spielers.
+	 * @return 	Der Name des Spielers
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * Liefert die aktuelle Traglast als Summe aller Gegenst<73>nde, die der Spieler tr<74>gt.
+	 * @return	Die aktuelle Traglast.
+	 */
+	public double getTraglast() {
+		double traglast = 0;
+		for (Gegenstand gegenstand : gegenstaende) {
+			traglast = traglast + gegenstand.getGewicht();
+		}
+		return traglast;
+	}
+
+	/**
+	 * Liefert die maximale Traglast des Spielers.
+	 * @return	Die maximale Traglast des Spielers.
+	 */
+	public double getTraglastMax() {
+		return traglastMax;
+	}
+
+	/**
+	 * Liefert den Fitnesszustand des Spielers.
+	 * @return	Der Fitnesszustand des Spielers.
+	 */
+	public int getFitness() {
+		return fitness;
+	}
+
+	/**
+	 * Liefert den aktuellen Bereich des Spielers.
+	 * @return	Der aktuelle Bereich des Spielers.
+	 */
+	public Bereich getBereich() {
+		return bereich;
+	}
+
+	/**
+	 * Gibt die Informationen <20>ber den Spieler zur<75>ck.
+	 * @return	Die Informationen <20>ber den Spieler.
+	 */
+	public String getInfo() {
+		StringBuilder info = new StringBuilder();
+		// Begr<67><72>ung ausgeben.
+		info.append(name + ", dein Fitnesswert betr<74>gt aktuell " + fitness + ".");
+		// Alle gegenst<73>nde ausgeben, wenn vorhanden.
+		if (gegenstaende.size() > 0) {
+			info.append("\nDu tr<74>gst folgenden Gegenst<73>nde mit dir:");
+			for (Gegenstand gegenstand : gegenstaende) {
+				info.append("\n\t" + gegenstand.getInfo());
+			}
+		}
+		// Info <20>ber den aktuellen Bereich ausgeben.
+		info.append(bereich.getInfo());
+        return info.toString();
+	}
+
+	/**
+	 * Geht in einen neuen Bereich, wenn die Kraft dazu reicht.
+	 * @param bereich	Der neue Bereich, in den der Spieler gehen soll.
+	 * @throws SpielerZuSchwachException	Wird geworfen, wenn der Spieler zu schwach ist, in den Bereich zu gehen.
+	 */
+	public void gehenInBereich(Bereich bereich) throws SpielerZuSchwachException {
+		if (fitness - VERBRAUCH_GEHEN >= 0) {
+			this.bereich = bereich;
+			fitness = fitness - VERBRAUCH_GEHEN;
+		}
+		else {
+			throw new SpielerZuSchwachException(this);
+		}
+	}
+
+	/**
+	 * Nimmt einen Gegenstand auf, wenn dadurch die maximale Tragkraft nicht <20>berschritten wird.
+	 * Nahrung kann nicht aufgenommen werden.
+	 * @param nameGegenstand	Der Name des aufzunehmende Gegenstandes.
+	 * @throws GegenstandNichtVorhandenException	Wird geworfen, wenn sich der aufzunehmende Gegenstand nicht im Bereich befindet.
+	 * @throws GegenstandZuSchwerException			Wird geworfen, wenn der aufzunehmende Gegenstand die maximale Tragkraft <20>berschreitet.
+	 */
+	public void aufnehmenGegenstand(String nameGegenstand) throws GegenstandNichtVorhandenException, GegenstandZuSchwerException {
+		Gegenstand gegenstand = bereich.suchenGegenstand(nameGegenstand);
+		if (gegenstand instanceof Nahrung == false) {
+			double traglast = getTraglast();
+			if(traglast + gegenstand.getGewicht() <= traglastMax) {
+				bereich.entfernenGegenstand(gegenstand);
+				gegenstaende.add(gegenstand);
+			}
+			else {
+				throw new GegenstandZuSchwerException(gegenstand);
+			}
+		}
+		else {
+			throw new GegenstandNichtVorhandenException("In diesem Bereich befindet sich leider kein Gegenstand mit dem Namen " + nameGegenstand + ".");
+		}
+	}
+
+	/**
+	 * Legt einen Gegenstand ab.
+	 * @param nameGegenstand	Der Name des abzulegenden Gegenstandes.
+	 * @throws GegenstandNichtVorhandenException	Wird geworfen, wenn kein Gegenstand den angegebenen Namen hat.
+	 */
+	public void ablegenGegenstand(String nameGegenstand) throws GegenstandNichtVorhandenException {
+		Gegenstand gegenstand = null;
+		for (Gegenstand g : gegenstaende) {
+			if (g.getName().equalsIgnoreCase(nameGegenstand)) {
+				gegenstand = g;
+				break;
+			}
+		}
+		if (gegenstand != null) {
+			gegenstaende.remove(gegenstand);
+			bereich.platzierenGegenstand(gegenstand);
+		}
+		else {
+			throw new GegenstandNichtVorhandenException("Du besitzt leider keinen Gegenstand mit dem Namen " + nameGegenstand + ".");
+		}
+	}
+
+	/**
+	 * Verzehrt Nahrung.
+	 * Ein Spieler kann allerdings nicht mehr essen, als er Hunger hat.
+	 * @param nameNahrung	Der Name der zu verzehrenden Nahrung.
+	 * @throws GegenstandNichtVorhandenException	Wird geworfen, wenn es die zu verzehrende Nahrung nicht im Bereich gibt.
+	 * @throws SpielerSattException					Wird geworfen, wenn der Spieler satt ist.
+	 */
+	public void essen(String nameNahrung) throws GegenstandNichtVorhandenException, SpielerSattException {
+		Gegenstand gegenstand = bereich.suchenGegenstand(nameNahrung);
+		if (gegenstand instanceof Nahrung) {
+			Nahrung nahrung = (Nahrung)gegenstand;
+			if (fitness + nahrung.getNaehrwert() <= FITNESS_Max) {
+				fitness = fitness + nahrung.getNaehrwert();
+			}
+			else {
+				fitness = FITNESS_Max;
+				throw new SpielerSattException(this);
+			}
+		}
+		else {
+			throw new GegenstandNichtVorhandenException("An diesem Ort befindet sich keine Nahrung mit dem Namen " + nameNahrung + ".");
+		}
+	}
+
+}

src/nogard/schritt6b/SpielerSattException.java

@@ -0,0 +1,27 @@
+package nogard.schritt6b;
+
+/**
+ * Die Exceptionklasse, die geworfen wird, wenn eine Person satt ist.
+ */
+public class SpielerSattException extends Exception {
+	
+	private Spieler spieler;
+
+	/**
+	 * Konstruktor.
+	 * @param spieler	Der Spieler, der zu schwach ist.
+	 */
+	public SpielerSattException(Spieler spieler) {
+		super();
+		this.spieler = spieler;
+	}
+
+	/* (non-Javadoc)
+	 * @see java.lang.Throwable#getMessage()
+	 */
+	@Override
+	public String getMessage() {
+		return spieler.getName() + ", du bist jetzt satt. Dein Fitnesswert betr<74>gt aktuell " + spieler.getFitness() + ".";
+	}
+
+}

src/nogard/schritt6b/SpielerZuSchwachException.java

@@ -0,0 +1,26 @@
+package nogard.schritt6b;
+
+/**
+ * Die Exceptionklasse, die geworfen wird, wenn ein Gegenstand nicht vorhanden ist.
+ */
+public class SpielerZuSchwachException extends Exception {
+	
+	private Spieler spieler;
+
+	/**
+	 * Konstruktor.
+	 * @param spieler	Der Spieler, der zu schwach ist.
+	 */
+	public SpielerZuSchwachException(Spieler spieler) {
+		this.spieler = spieler;
+	}
+
+	/* (non-Javadoc)
+	 * @see java.lang.Throwable#getMessage()
+	 */
+	@Override
+	public String getMessage() {
+		return "!!! ACHTUNG !!!   " + spieler.getName() + ", du bist zu schwach. Dein Fitnesswert betr<74>gt aktuell " + spieler.getFitness() + ".";
+	}
+
+}