diff --git a/.idea/encodings.xml b/.idea/encodings.xml
index b328ef5..1dff6a6 100644
--- a/.idea/encodings.xml
+++ b/.idea/encodings.xml
@@ -10,14 +10,15 @@
-
-
-
-
+
+
+
+
+
\ No newline at end of file
diff --git a/src/nogard/schritt5/Befehl.java b/src/nogard/schritt5/Befehl.java
index b7c0cf2..f9833eb 100644
--- a/src/nogard/schritt5/Befehl.java
+++ b/src/nogard/schritt5/Befehl.java
@@ -1,26 +1,51 @@
-package nogard.schritt5;
+package nogard.schritt5;
+/**
+ * Objekte dieser Klasse halten Informationen �ber Befehle, die der Benutzer eingegeben hat.
+ *
+ * Ein Befehl besteht momentan aus zwei Zeichenketten:
+ * - einer ersten Zeichenkette, die das Schl�sselwort des Befehls angibt und
+ * - einer zweiten Zeichenkette, die einen Zusatz zum Befehl enth�lt.
+ *
+ * Beim Befehl "go north" sind die beiden Zeichenketten des Befehls
+ * - "go" und
+ * - "north".
+ *
+ * Wenn der Befehl nur aus einem Schl�sselwort besteht, dann ist das zweite Wort 'null'.
+ */
public class Befehl {
- private final String befehl_wort;
- private final String befehl_zusatz;
+
+ private String befehlsWort;
+ private String befehlsZusatz;
- public Befehl(String wort) {
- befehl_wort = wort;
- befehl_zusatz = null;
+ /**
+ * Konstruktor.
+ * @param befehlsWort Das Schl�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�sselwort besteht.
+ */
+ public Befehl(String befehlsWort, String befehlsZusatz) {
+ this.befehlsWort = befehlsWort;
+ this.befehlsZusatz = befehlsZusatz;
}
- public Befehl(String wort, String zusatz) {
- befehl_wort = wort;
- befehl_zusatz = zusatz;
+ /**
+ * Liefert das Schl�sselwort des Befehls.
+ * @return Das Schl�sselwort des Befehls.
+ */
+ public String getBefehlsWort() {
+ return befehlsWort;
}
- public String getWort() {
- return befehl_wort;
+ /**
+ * Liefert den Zusatz zum Befehl.
+ * Wenn es keinen Befehlszusatz gibt, ist das Ergebnis 'null'.
+ * @return Den Zusatz zum Befehl.
+ */
+ public String getBefehlsZusatz() {
+ return befehlsZusatz;
}
-
- public String getZusatz() {
- return befehl_zusatz;
- }
-
-
+
}
+
diff --git a/src/nogard/schritt5/BefehlFactory.java b/src/nogard/schritt5/BefehlFactory.java
index d4cb8a0..e0e5536 100644
--- a/src/nogard/schritt5/BefehlFactory.java
+++ b/src/nogard/schritt5/BefehlFactory.java
@@ -1,38 +1,61 @@
-package nogard.schritt5;
-
-import java.util.Arrays;
+package nogard.schritt5;
+/**
+ * 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üsselwort, so ist der Zusatz des Befehls 'null'.
+ */
public class BefehlFactory {
-
- public static Befehl createBefehl(String input) throws BefehlUnbekanntException {
- Befehl b;
- if (input.length() == 0) {
- throw new BefehlUnbekanntException("Keine Argumente übergeben");
- } else {
- String[] befehl_str = input.toLowerCase().split(" ");
- String wort = befehl_str[0];
- b = switch (wort) {
- case "go" -> createGoBefehl(befehl_str);
- case "help", "quit" -> new Befehl(wort);
- default -> throw new BefehlUnbekanntException(wort + " ist kein definierter Befehl.");
- };
+ /**
+ * 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ü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.");
}
- return b;
- }
-
- private static Befehl createGoBefehl(String[] befehl_str) throws BefehlUnbekanntException {
- if (befehl_str.length != 2) {
- throw new BefehlUnbekanntException("Befehl 'go' benötigt 2 parameter");
- }
-
- String befehl_wort = befehl_str[0];
- String befehl_zusatz = befehl_str[1];
-
- for (Richtungen r: Richtungen.values()) {
- if (r.name().equalsIgnoreCase(befehl_zusatz)) {
- return new Befehl(befehl_wort, befehl_zusatz);
- }
- }
- throw new BefehlUnbekanntException(befehl_zusatz + " ist keine valide Richtung.");
- }
+ // 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üfen der angegebenen Richtung per Schleife ü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ä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ß nicht, was du meinst ...");
+ }
+ return befehl;
+ }
+
}
diff --git a/src/nogard/schritt5/BefehlUnbekanntException.java b/src/nogard/schritt5/BefehlUnbekanntException.java
index f99ede4..c323ad9 100644
--- a/src/nogard/schritt5/BefehlUnbekanntException.java
+++ b/src/nogard/schritt5/BefehlUnbekanntException.java
@@ -1,14 +1,26 @@
-package nogard.schritt5;
+package nogard.schritt5;
+/**
+ * Die Exceptionklasse, die geworfen wird, wenn ein Befehl unbekannt ist.
+ */
public class BefehlUnbekanntException extends Exception {
- private String befehl;
+
+ private String meldung;
+
+ /**
+ * Konstruktor.
+ * @param meldung Die Fehlermeldung.
+ */
+ public BefehlUnbekanntException(String meldung) {
+ this.meldung = meldung;
+ }
- public BefehlUnbekanntException(String befehl) {
- this.befehl = befehl;
- }
+ /* (non-Javadoc)
+ * @see java.lang.Throwable#getMessage()
+ */
+ @Override
+ public String getMessage() {
+ return meldung;
+ }
- @Override
- public String getMessage() {
- return befehl;
- }
}
diff --git a/src/nogard/schritt5/Bereich.java b/src/nogard/schritt5/Bereich.java
index 247e879..dfe873f 100644
--- a/src/nogard/schritt5/Bereich.java
+++ b/src/nogard/schritt5/Bereich.java
@@ -1,33 +1,34 @@
-package nogard.schritt5;
+package nogard.schritt5;
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.
+ * Diese Klasse modelliert Bereiche. Ein Bereich kann ein Gebiet, ein Haus, ein Raum etc. sein.
*
- * Jeder Bereich ist mit anderen Bereichen �ber Ausg�nge verbunden. M�gliche Ausg�nge liegen im Norden, Osten, S�den und Westen.
+ * Jeder Bereich ist mit anderen Bereichen über Ausgänge verbunden. Mögliche Ausgä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.
+ * Für jeden Ausgang hält ein Bereich eine Referenz auf den benachbarten Bereich parat.
*/
public class Bereich {
+
+ private String beschreibung;
+ private Map nachbarn;
+ private List gegenstaende;
- private final String beschreibung;
- private final Map nachbarn;
- private final LinkedList 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);
+ for (Richtungen richtung : Richtungen.values()) {
+ nachbarn.put(richtung, null);
}
+ gegenstaende = new LinkedList<>();
}
/**
@@ -38,60 +39,82 @@ public class Bereich {
return beschreibung;
}
+ /**
+ * Liefert einen benachbarten Bereich.
+ * @param richtung Die Richtung des gewünschten benachbarten Bereichs.
+ * @return Der gewünschte benachbarte Bereich.
+ */
+ public Bereich getNachbar(Richtungen richtung) {
+ return nachbarn.get(richtung);
+ }
+
/**
- * Setzt den Nachbarn des Bereiches.
- * @param r Die Richtung / Ort des Nachbarbereichs.
- * @param n Der Nachbar welcher Relativ zu diesem Objekt liegt.
+ * Gibt die Informationen über den Bereich zurück.
+ * @return Die Informationen über den Bereich.
*/
- 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("Du bist im Bereich ");
- sb.append(getBeschreibung());
- sb.append("\nDeine Nachbarn sind:\n");
- for (Map.Entry paar: nachbarn.entrySet()) {
- if (paar.getValue() != null) {
- sb.append("\n\t").append(paar.getKey().name());
+ StringBuilder info = new StringBuilder();
+ info.append("\nDu befindest dich " + beschreibung + ".");
+ // Alle gegenstände ausgeben, wenn vorhanden.
+ if (gegenstaende.size() > 0) {
+ info.append("\nHier befinden sich die folgenden Gegenstände:");
+ for (Gegenstand gegenstand : gegenstaende) {
+ info.append("\n\t" + gegenstand.getInfo());
}
}
- sb.append("\nGegenstände:\n");
- for (Gegenstand g: gegenstaende) {
- sb.append("\n\t").append(g.getInfo());
+ info.append("\nDu kannst gehen nach:");
+ // Alle nichtleeren Bereiche ausgeben.
+ for (Map.Entry paar : nachbarn.entrySet()) {
+ if (paar.getValue() != null) {
+ info.append("\n\t" + paar.getKey().name().toLowerCase());
+ }
}
-
- return sb.toString();
+ 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ügende benachbarte Bereich befindet.
+ * @param nachbar Der hinzuzufügende benachbarte Bereich.
+ */
+ public void setNachbar(Richtungen richtung, Bereich nachbar) {
+ nachbarn.put(richtung, nachbar);
+ }
+
+ /**
+ * Fügt einen neuen Gegenstand dem Bereich hinzu.
+ * @param gegenstand Der hinzuzufü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 + ".");
+ }
+
}
diff --git a/src/nogard/schritt5/Gegenstand.java b/src/nogard/schritt5/Gegenstand.java
index 5559f03..dffbfdf 100644
--- a/src/nogard/schritt5/Gegenstand.java
+++ b/src/nogard/schritt5/Gegenstand.java
@@ -1,32 +1,56 @@
package nogard.schritt5;
+/**
+ * Diese Klasse modelliert einen Gegenstand.
+ */
public class Gegenstand {
- private String name;
- private String description;
- private float weight_kg;
+
+ 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;
+ }
- public Gegenstand(String name, String description, float weight_kg) {
- this.name = name;
- this.description = description;
- this.weight_kg = weight_kg;
- }
+ /**
+ * Liefert den Namen des Gegenstandes.
+ * @return Der Name des Gegenstandes.
+ */
+ public String getName() {
+ return name;
+ }
- public String getName() {
- return name;
- }
+ /**
+ * Liefert die Beschreibung des Gegenstandes.
+ * @return Die Beschreibung des Gegenstandes.
+ */
+ public String getBeschreibung() {
+ return beschreibung;
+ }
- public String getDescription() {
- return description;
- }
+ /**
+ * Liefert das Gewicht des Gegenstandes in kg.
+ * @return Das Gewicht des Gegenstandes in kg.
+ */
+ public double getGewicht() {
+ return gewicht;
+ }
+
+ /**
+ * Gibt die Informationen über den Gegenstand zurück.
+ * @return Die Informationen über den Gegenstand.
+ */
+ public String getInfo() {
+ return name + " " + beschreibung + " mit einem Gewicht von " + gewicht + " kg";
+ }
- public float getWeight_kg() {
- return weight_kg;
- }
-
- public String getInfo() {
- return "Name: " + name +
- "\nBeschreibung: " + description +
- "\nGewicht" + weight_kg +
- "\n";
- }
}
diff --git a/src/nogard/schritt5/GegenstandNichtVorhandenException.java b/src/nogard/schritt5/GegenstandNichtVorhandenException.java
index 62b23ee..e62db63 100644
--- a/src/nogard/schritt5/GegenstandNichtVorhandenException.java
+++ b/src/nogard/schritt5/GegenstandNichtVorhandenException.java
@@ -1,20 +1,26 @@
-package nogard.schritt5;
+package nogard.schritt5;
+/**
+ * Die Exceptionklasse, die geworfen wird, wenn ein Gegenstand nicht vorhanden ist.
+ */
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();
- }
+
+ private String meldung;
+
+ /**
+ * Konstruktor.
+ * @param meldung Die Fehlermeldung.
+ */
+ public GegenstandNichtVorhandenException(String meldung) {
+ this.meldung = meldung;
+ }
- public GegenstandNichtVorhandenException(String text) {
- this.text = text;
- }
+ /* (non-Javadoc)
+ * @see java.lang.Throwable#getMessage()
+ */
+ @Override
+ public String getMessage() {
+ return meldung;
+ }
- @Override
- public String getMessage() {
- return text;
- }
}
diff --git a/src/nogard/schritt5/GegenstandZuSchwerException.java b/src/nogard/schritt5/GegenstandZuSchwerException.java
index 11f830a..16cc417 100644
--- a/src/nogard/schritt5/GegenstandZuSchwerException.java
+++ b/src/nogard/schritt5/GegenstandZuSchwerException.java
@@ -1,9 +1,26 @@
-package nogard.schritt5;
+package nogard.schritt5;
+/**
+ * Die Exceptionklasse, die geworfen wird, wenn ein Gegenstand nicht vorhanden ist.
+ */
public class GegenstandZuSchwerException extends Exception {
- private final String text;
+
+ 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.";
+ }
- public GegenstandZuSchwerException(Gegenstand g) {
- text = "Ist zu schwer: " + g.getDescription();
- }
}
diff --git a/src/nogard/schritt5/Nahrung.java b/src/nogard/schritt5/Nahrung.java
index 56967a7..25a8ce4 100644
--- a/src/nogard/schritt5/Nahrung.java
+++ b/src/nogard/schritt5/Nahrung.java
@@ -1,19 +1,38 @@
-package nogard.schritt5;
+package nogard.schritt5;
+/**
+ * Diese Klasse modelliert Nahrung als einen speziellen Gegenstand.
+ */
public class Nahrung extends Gegenstand {
- private final int nutrients;
- public Nahrung(String name, String description, float weight_kg, int nutrients) {
- super(name, description, weight_kg);
- this.nutrients = nutrients;
- }
+ 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 über die Nahrung zurück.
+ * @return Die Informationen über die Nahrung.
+ */
+ @Override
+ public String getInfo() {
+ return getName() + " " + getBeschreibung() + " mit einem Nährwert von " + naehrwert + " kcal";
+ }
- public int getNutrients() {
- return nutrients;
- }
-
- public String getInfo() {
- return super.getInfo() +
- getNutrients();
- }
}
diff --git a/src/nogard/schritt5/Program.java b/src/nogard/schritt5/Program.java
index afc254b..81efdde 100644
--- a/src/nogard/schritt5/Program.java
+++ b/src/nogard/schritt5/Program.java
@@ -1,4 +1,4 @@
-package nogard.schritt5;
+package nogard.schritt5;
public class Program {
diff --git a/src/nogard/schritt5/Richtungen.java b/src/nogard/schritt5/Richtungen.java
index 59343ab..45dca5b 100644
--- a/src/nogard/schritt5/Richtungen.java
+++ b/src/nogard/schritt5/Richtungen.java
@@ -1,5 +1,10 @@
-package nogard.schritt5;
+package nogard.schritt5;
+/**
+ * Aufzählung aller möglichen Richtungen
+ */
public enum Richtungen {
- NORTH, EAST, SOUTH, WEST, UP, DOWN
+
+ NORTH, EAST, SOUTH, WEST, UP, DOWN;
+
}
diff --git a/src/nogard/schritt5/Spiel.java b/src/nogard/schritt5/Spiel.java
index f2d0d62..e22a7d5 100644
--- a/src/nogard/schritt5/Spiel.java
+++ b/src/nogard/schritt5/Spiel.java
@@ -1,122 +1,199 @@
-package nogard.schritt5;
+package nogard.schritt5;
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!
+ * Dies ist die Hauptklasse der Anwendung "Die Welt von Nogard".
*
- * Zum Spielen muss an einer Instanz dieser Klasse die Methode "spielen()" aufgerufen werden.
+ * "Die Welt von Nogard" ist ein sehr einfaches, textbasiertes Adventure-Game,
+ * in dem sich ein Spieler durch Nogard bewegen kann.
*
- * Diese Klasse erzeugt und initialisiert alle Objekte der Anwendung:
- * - Sie legt alle Bereiche an. Anschlie�end startet das Spiel.
- * - Sie wertet die Befehle aus und sorgt f�r ihre Ausf�hrung.
+ * 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ßend startet das Spiel.
+ * - Sie wertet die Befehle aus und sorgt für ihre Ausführung.
*/
public class Spiel {
- private Bereich aktiverBereich;
+ 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() {
+
+ /**
+ * Die Hauptmethode zum Spielen. Läuft bis zum Ende des Spiels in einer
+ * Schleife.
+ */
+ public void spielen() {
+ // Begrüßungsbildschirm ausgeben.
ausgebenStartText();
// Befehle einlesen und auswerten.
- Scanner scannerZeile = new Scanner(System.in);
-
+ Scanner scannerZeile = new Scanner(System.in);
boolean end = false;
- while (! end) {
- // Eingabeaufforderung anzeigen.
- System.out.print("> ");
+ while (!end) {
+ // Eingabeaufforderung anzeigen.
+ System.out.print("> ");
+ // Befehlszeile lesen.
String input = scannerZeile.nextLine();
try {
+ // Befehls-Objekt erzeugen.
Befehl befehl = BefehlFactory.createBefehl(input);
+ // Befehl ausführen.
end = ausfuehrenBefehl(befehl);
} catch (BefehlUnbekanntException e) {
System.out.println(e.getMessage());
}
}
-
- // Endbildschirm ausgeben.
+
+ // Endbildschirm ausgeben.
ausgebenEndText();
}
+ /**
+ * Erzeugt alle Bereiche und erstellt die Dorfstruktur ü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ä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ände in die Bereiche legen.
+ friedhof.platzierenGegenstand(new Gegenstand("Taschentuch", "zum Trocknen deiner Tränen", 0.1));
+ hexenhaus.platzierenGegenstand(new Gegenstand("Kessel", "zum Kochen der Zaubertränke", 5.0));
+ hexenhaus.platzierenGegenstand(new Gegenstand("Krug", "mit fauligem Krötenwasser", 5.0));
+ hexenhaus.platzierenGegenstand(new Gegenstand("Schale", "mit getrockneten Krä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ößen und klumpiger Soß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ßen Punkten", 200));
+ weinkeller.platzierenGegenstand(new Gegenstand("Fass", "mit lange gelagertem Rotwein", 10.0));
+ hoehle.platzierenGegenstand(new Gegenstand("Spinne", "mit groß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ührende Befehl.
+ * @return , wenn der Befehl das Spiel beendet, sonst.
+ */
private boolean ausfuehrenBefehl(Befehl befehl) {
- boolean end = false;
- switch (befehl.getWort()) {
- case "go" -> wechselBereich(befehl);
- case "help" -> ausgebenHilfeText();
- case "quit" -> end = true;
- default -> ausgebenFehlerBefehl();
+ switch (befehl.getBefehlsWort()) {
+ case "go":
+ wechselBereich(befehl);
+ return false;
+ case "help":
+ ausgebenHilfeText();
+ return false;
+ case "quit":
+ return true;
+ default:
+ ausgebenFehlerBefehl();
+ return false;
}
- return end;
}
+ /**
+ * Wechseln des Bereichs. Wenn es einen benachbarten Bereich gibt, wird dorthin
+ * gegangen, ansonsten gibt es eine Fehlermeldung.
+ *
+ * @param befehl Der auszuführende Befehl.
+ */
private void wechselBereich(Befehl befehl) {
- Richtungen richtung = Richtungen.valueOf(befehl.getZusatz().toUpperCase());
- Bereich neuerBereich = aktiverBereich.getNachbar(richtung);
-
+ // 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("Hier geht es nicht weiter");
+ System.out.println("Dort geht es nicht weiter.");
} else {
- aktiverBereich = neuerBereich;
+ try {
+ spieler.gehenInBereich(neuerBereich);
+ } catch (SpielerZuSchwachException e) {
+ System.out.println(e.getMessage());
+ }
+ System.out.println(spieler.getInfo());
}
- System.out.println(aktiverBereich.getInfo());
}
+ /**
+ * Gibt einen Begrüßungstext auf der Konsole aus.
+ */
+ private void ausgebenStartText() {
+ 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());
+ }
+
+ /**
+ * 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�gung:");
+ System.out.println("Dir stehen folgende Befehle zur Verfü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.");
- }
-
- private void ausgebenStartText() {
- // Begr��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(aktiverBereich.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);
-
- // Das Spielt startet im Wald.
- aktiverBereich = wald;
+ 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� nicht, was Du meinst ...");
+ System.out.println("Ich weiß nicht, was Du meinst ...");
}
}
diff --git a/src/nogard/schritt5/Spieler.java b/src/nogard/schritt5/Spieler.java
index e84fd2c..9949868 100644
--- a/src/nogard/schritt5/Spieler.java
+++ b/src/nogard/schritt5/Spieler.java
@@ -1,46 +1,190 @@
-package nogard.schritt5;
+package nogard.schritt5;
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ühren.
+ *
+ * Der Spieler kann Nahrung verzehren und damit Energie auftanken.
+ * Allerdings ist die Aufnahme von Nahrung begrenzt.
+ */
public class Spieler {
- private final String name;
- private final float traglast;
- private final int fitness;
- private final LinkedList items;
- private final Bereich bereich;
+
+ 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 gegenstaende;
+
+ /**
+ * Konstruktor.
+ * @param name Der Name des Spielers.
+ * @param traglastMax Die maximale Traglast, die der Spieler bewä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<>();
+ }
- public Spieler(String name, float traglast, int fitness, Bereich bereich) {
- this.name = name;
- this.traglast = traglast;
- this.fitness = fitness;
- items = new LinkedList<>();
- this.bereich = bereich;
- }
+ /**
+ * Liefert den Namen des Spielers.
+ * @return Der Name des Spielers
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * Liefert die aktuelle Traglast als Summe aller Gegenstände, die der Spieler trägt.
+ * @return Die aktuelle Traglast.
+ */
+ public double getTraglast() {
+ double traglast = 0;
+ for (Gegenstand gegenstand : gegenstaende) {
+ traglast = traglast + gegenstand.getGewicht();
+ }
+ return traglast;
+ }
- public float getTraglast() {
- float total_weight_kg = 0;
- for (Gegenstand g: items) {
- total_weight_kg += g.getWeight_kg();
- }
- return total_weight_kg;
- }
+ /**
+ * Liefert die maximale Traglast des Spielers.
+ * @return Die maximale Traglast des Spielers.
+ */
+ public double getTraglastMax() {
+ return traglastMax;
+ }
- public void aufnehmenGegenstand(Gegenstand g) {
- items.add(g);
- }
+ /**
+ * Liefert den Fitnesszustand des Spielers.
+ * @return Der Fitnesszustand des Spielers.
+ */
+ public int getFitness() {
+ return fitness;
+ }
- 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(traglast);
- sb.append("\n\tItems: [");
- for (Gegenstand g: items) {
- sb.append(g.getName()).append(", ");
- }
- sb.append("\n\tBereich: ").append(bereich.getBeschreibung());
+ /**
+ * Liefert den aktuellen Bereich des Spielers.
+ * @return Der aktuelle Bereich des Spielers.
+ */
+ public Bereich getBereich() {
+ return bereich;
+ }
+
+ /**
+ * Gibt die Informationen über den Spieler zurück.
+ * @return Die Informationen über den Spieler.
+ */
+ public String getInfo() {
+ StringBuilder info = new StringBuilder();
+ // Begrüßung ausgeben.
+ info.append(name + ", dein Fitnesswert beträgt aktuell " + fitness + ".");
+ // Alle gegenstände ausgeben, wenn vorhanden.
+ if (gegenstaende.size() > 0) {
+ info.append("\nDu trägst folgenden Gegenstände mit dir:");
+ for (Gegenstand gegenstand : gegenstaende) {
+ info.append("\n\t" + gegenstand.getInfo());
+ }
+ }
+ // Info ü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 ü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 ü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 + ".");
+ }
+ }
- return sb.toString();
- }
}
diff --git a/src/nogard/schritt5/SpielerSattException.java b/src/nogard/schritt5/SpielerSattException.java
new file mode 100644
index 0000000..8e13e34
--- /dev/null
+++ b/src/nogard/schritt5/SpielerSattException.java
@@ -0,0 +1,27 @@
+package nogard.schritt5;
+
+/**
+ * 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ägt aktuell " + spieler.getFitness() + ".";
+ }
+
+}
diff --git a/src/nogard/schritt5/SpielerZuSchwachException.java b/src/nogard/schritt5/SpielerZuSchwachException.java
new file mode 100644
index 0000000..7083506
--- /dev/null
+++ b/src/nogard/schritt5/SpielerZuSchwachException.java
@@ -0,0 +1,26 @@
+package nogard.schritt5;
+
+/**
+ * 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ägt aktuell " + spieler.getFitness() + ".";
+ }
+
+}
diff --git a/src/nogard/schritt5b/Befehl.java b/src/nogard/schritt5b/Befehl.java
new file mode 100644
index 0000000..6f0c6e0
--- /dev/null
+++ b/src/nogard/schritt5b/Befehl.java
@@ -0,0 +1,26 @@
+package nogard.schritt5b;
+
+public class Befehl {
+ private final String befehl_wort;
+ private final String befehl_zusatz;
+
+ public Befehl(String wort) {
+ befehl_wort = wort;
+ befehl_zusatz = null;
+ }
+
+ public Befehl(String wort, String zusatz) {
+ befehl_wort = wort;
+ befehl_zusatz = zusatz;
+ }
+
+ public String getWort() {
+ return befehl_wort;
+ }
+
+ public String getZusatz() {
+ return befehl_zusatz;
+ }
+
+
+}
diff --git a/src/nogard/schritt5b/BefehlFactory.java b/src/nogard/schritt5b/BefehlFactory.java
new file mode 100644
index 0000000..a8a4886
--- /dev/null
+++ b/src/nogard/schritt5b/BefehlFactory.java
@@ -0,0 +1,38 @@
+package nogard.schritt5b;
+
+import java.util.Arrays;
+
+public class BefehlFactory {
+
+ public static Befehl createBefehl(String input) throws BefehlUnbekanntException {
+ Befehl b;
+ if (input.length() == 0) {
+ throw new BefehlUnbekanntException("Keine Argumente übergeben");
+ } else {
+ String[] befehl_str = input.toLowerCase().split(" ");
+ String wort = befehl_str[0];
+ b = switch (wort) {
+ case "go" -> createGoBefehl(befehl_str);
+ case "help", "quit" -> new Befehl(wort);
+ default -> throw new BefehlUnbekanntException(wort + " ist kein definierter Befehl.");
+ };
+ }
+ return b;
+ }
+
+ private static Befehl createGoBefehl(String[] befehl_str) throws BefehlUnbekanntException {
+ if (befehl_str.length != 2) {
+ throw new BefehlUnbekanntException("Befehl 'go' benötigt 2 parameter");
+ }
+
+ String befehl_wort = befehl_str[0];
+ String befehl_zusatz = befehl_str[1];
+
+ for (Richtungen r: Richtungen.values()) {
+ if (r.name().equalsIgnoreCase(befehl_zusatz)) {
+ return new Befehl(befehl_wort, befehl_zusatz);
+ }
+ }
+ throw new BefehlUnbekanntException(befehl_zusatz + " ist keine valide Richtung.");
+ }
+}
diff --git a/src/nogard/schritt5b/BefehlUnbekanntException.java b/src/nogard/schritt5b/BefehlUnbekanntException.java
new file mode 100644
index 0000000..92fb300
--- /dev/null
+++ b/src/nogard/schritt5b/BefehlUnbekanntException.java
@@ -0,0 +1,14 @@
+package nogard.schritt5b;
+
+public class BefehlUnbekanntException extends Exception {
+ private String befehl;
+
+ public BefehlUnbekanntException(String befehl) {
+ this.befehl = befehl;
+ }
+
+ @Override
+ public String getMessage() {
+ return befehl;
+ }
+}
diff --git a/src/nogard/schritt5b/Bereich.java b/src/nogard/schritt5b/Bereich.java
new file mode 100644
index 0000000..9bae574
--- /dev/null
+++ b/src/nogard/schritt5b/Bereich.java
@@ -0,0 +1,97 @@
+package nogard.schritt5b;
+
+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 �ber Ausg�nge verbunden. M�gliche Ausg�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 nachbarn;
+ private final LinkedList 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("Du bist im Bereich ");
+ sb.append(getBeschreibung());
+ sb.append("\nDeine Nachbarn sind:\n");
+ for (Map.Entry paar: nachbarn.entrySet()) {
+ if (paar.getValue() != null) {
+ sb.append("\n\t").append(paar.getKey().name());
+ }
+ }
+ sb.append("\nGegenstände:\n");
+ for (Gegenstand g: gegenstaende) {
+ sb.append("\n\t").append(g.getInfo());
+ }
+
+ return sb.toString();
+ }
+}
diff --git a/src/nogard/schritt5b/Gegenstand.java b/src/nogard/schritt5b/Gegenstand.java
new file mode 100644
index 0000000..02ca3ba
--- /dev/null
+++ b/src/nogard/schritt5b/Gegenstand.java
@@ -0,0 +1,32 @@
+package nogard.schritt5b;
+
+public class Gegenstand {
+ private String name;
+ private String description;
+ private float weight_kg;
+
+ public Gegenstand(String name, String description, float weight_kg) {
+ this.name = name;
+ this.description = description;
+ this.weight_kg = weight_kg;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ public float getWeight_kg() {
+ return weight_kg;
+ }
+
+ public String getInfo() {
+ return "Name: " + name +
+ "\nBeschreibung: " + description +
+ "\nGewicht" + weight_kg +
+ "\n";
+ }
+}
diff --git a/src/nogard/schritt5b/GegenstandNichtVorhandenException.java b/src/nogard/schritt5b/GegenstandNichtVorhandenException.java
new file mode 100644
index 0000000..5c96b21
--- /dev/null
+++ b/src/nogard/schritt5b/GegenstandNichtVorhandenException.java
@@ -0,0 +1,20 @@
+package nogard.schritt5b;
+
+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;
+ }
+}
diff --git a/src/nogard/schritt5b/GegenstandZuSchwerException.java b/src/nogard/schritt5b/GegenstandZuSchwerException.java
new file mode 100644
index 0000000..66bd99f
--- /dev/null
+++ b/src/nogard/schritt5b/GegenstandZuSchwerException.java
@@ -0,0 +1,9 @@
+package nogard.schritt5b;
+
+public class GegenstandZuSchwerException extends Exception {
+ private final String text;
+
+ public GegenstandZuSchwerException(Gegenstand g) {
+ text = "Ist zu schwer: " + g.getDescription();
+ }
+}
diff --git a/src/nogard/schritt5b/Nahrung.java b/src/nogard/schritt5b/Nahrung.java
new file mode 100644
index 0000000..573fb0d
--- /dev/null
+++ b/src/nogard/schritt5b/Nahrung.java
@@ -0,0 +1,19 @@
+package nogard.schritt5b;
+
+public class Nahrung extends Gegenstand {
+ private final int nutrients;
+
+ public Nahrung(String name, String description, float weight_kg, int nutrients) {
+ super(name, description, weight_kg);
+ this.nutrients = nutrients;
+ }
+
+ public int getNutrients() {
+ return nutrients;
+ }
+
+ public String getInfo() {
+ return super.getInfo() +
+ getNutrients();
+ }
+}
diff --git a/src/nogard/schritt5b/Program.java b/src/nogard/schritt5b/Program.java
new file mode 100644
index 0000000..306928c
--- /dev/null
+++ b/src/nogard/schritt5b/Program.java
@@ -0,0 +1,9 @@
+package nogard.schritt5b;
+
+public class Program {
+
+ public static void main(String[] args) {
+ new Spiel().spielen();
+ }
+
+}
diff --git a/src/nogard/schritt5b/Richtungen.java b/src/nogard/schritt5b/Richtungen.java
new file mode 100644
index 0000000..f9beb6b
--- /dev/null
+++ b/src/nogard/schritt5b/Richtungen.java
@@ -0,0 +1,5 @@
+package nogard.schritt5b;
+
+public enum Richtungen {
+ NORTH, EAST, SOUTH, WEST, UP, DOWN
+}
diff --git a/src/nogard/schritt5b/Spiel.java b/src/nogard/schritt5b/Spiel.java
new file mode 100644
index 0000000..c023bcf
--- /dev/null
+++ b/src/nogard/schritt5b/Spiel.java
@@ -0,0 +1,122 @@
+package nogard.schritt5b;
+
+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�end startet das Spiel.
+ * - Sie wertet die Befehle aus und sorgt f�r ihre Ausf�hrung.
+ */
+public class Spiel {
+ private Bereich aktiverBereich;
+
+ 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 {
+ Befehl befehl = BefehlFactory.createBefehl(input);
+ end = ausfuehrenBefehl(befehl);
+ } catch (BefehlUnbekanntException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+
+ // Endbildschirm ausgeben.
+ ausgebenEndText();
+ }
+
+ private boolean ausfuehrenBefehl(Befehl befehl) {
+ boolean end = false;
+ switch (befehl.getWort()) {
+ case "go" -> wechselBereich(befehl);
+ case "help" -> ausgebenHilfeText();
+ case "quit" -> end = true;
+ default -> ausgebenFehlerBefehl();
+ }
+ return end;
+ }
+
+ private void wechselBereich(Befehl befehl) {
+ Richtungen richtung = Richtungen.valueOf(befehl.getZusatz().toUpperCase());
+ Bereich neuerBereich = aktiverBereich.getNachbar(richtung);
+
+ if (neuerBereich == null) {
+ System.out.println("Hier geht es nicht weiter");
+ } else {
+ aktiverBereich = neuerBereich;
+ }
+ System.out.println(aktiverBereich.getInfo());
+ }
+
+ private void ausgebenHilfeText() {
+ System.out.println("Du irrst in Nogard herum.");
+ System.out.println("Dir stehen folgende Befehle zur Verf�gung:");
+ System.out.println("\tgo");
+ System.out.println("\tquit");
+ System.out.println("\thelp");
+ }
+
+ private void ausgebenEndText() {
+ System.out.println("Danke f�r dieses Spiel. Auf Wiedersehen.");
+ }
+
+ private void ausgebenStartText() {
+ // Begr��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(aktiverBereich.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);
+
+ // Das Spielt startet im Wald.
+ aktiverBereich = wald;
+ }
+
+ private void ausgebenFehlerBefehl() {
+ System.out.println("Ich wei� nicht, was Du meinst ...");
+ }
+
+}
diff --git a/src/nogard/schritt5b/Spieler.java b/src/nogard/schritt5b/Spieler.java
new file mode 100644
index 0000000..1afff31
--- /dev/null
+++ b/src/nogard/schritt5b/Spieler.java
@@ -0,0 +1,46 @@
+package nogard.schritt5b;
+
+import java.util.LinkedList;
+
+public class Spieler {
+ private final String name;
+ private final float traglast;
+ private final int fitness;
+ private final LinkedList items;
+ private final Bereich bereich;
+
+ public Spieler(String name, float traglast, int fitness, Bereich bereich) {
+ this.name = name;
+ this.traglast = traglast;
+ this.fitness = fitness;
+ items = new LinkedList<>();
+ this.bereich = bereich;
+ }
+
+ public float getTraglast() {
+ float total_weight_kg = 0;
+ for (Gegenstand g: items) {
+ total_weight_kg += g.getWeight_kg();
+ }
+ return total_weight_kg;
+ }
+
+ public void aufnehmenGegenstand(Gegenstand g) {
+ items.add(g);
+ }
+
+ 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(traglast);
+ sb.append("\n\tItems: [");
+ for (Gegenstand g: items) {
+ sb.append(g.getName()).append(", ");
+ }
+ sb.append("\n\tBereich: ").append(bereich.getBeschreibung());
+
+ return sb.toString();
+ }
+}