janis/lf05-java
1
0
Fork 0
mirror of https://github.com/DerTyp7/lf05-java.git synced 2025-10-29 04:22:12 +01:00
Code Issues Packages Projects Releases Wiki Activity

nogard 5

Browse Source
This commit is contained in:
Janis M
2022-04-25 13:36:21 +02:00
parent edbd51a7d6
commit fbcc1a7371
27 changed files with 1159 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
.idea/encodings.xml generated
View File

@@ -10,14 +10,15 @@
<file url="file://$PROJECT_DIR$/src/nogard/schritt2/schritt1/Bereich.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt2/schritt1/Spiel.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt3/Bereich.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt3/Bereich.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt3/Spiel.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt3/Spiel.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt3/schritt3/Bereich.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt3/schritt3/Spiel.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt4/Bereich.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt4/Bereich.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt4/Spiel.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt4/Spiel.java" charset="windows-1252" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt5/Befehl.java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/nogard/schritt5/BefehlFactory.java" charset="windows-1252" />
<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" />
</component>
</project>

59
src/nogard/schritt5/Befehl.java
View File

@@ -1,26 +1,51 @@
package nogard.schritt5;
package nogard.schritt5;
/**
* 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 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<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;
}
public Befehl(String wort, String zusatz) {
befehl_wort = wort;
befehl_zusatz = zusatz;
/**
* Liefert das Schl<68>sselwort des Befehls.
* @return Das Schl<68>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;
}
}

91
src/nogard/schritt5/BefehlFactory.java
View File

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

30
src/nogard/schritt5/BefehlUnbekanntException.java
View File

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

145
src/nogard/schritt5/Bereich.java
View File

@@ -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 <20>ber Ausg<73>nge verbunden. M<>gliche Ausg<73>nge liegen im Norden, Osten, S<>den und Westen.
* 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.
* F<>r jeden Ausgang h<>lt ein Bereich eine Referenz auf den benachbarten Bereich parat.
*/
public class Bereich {
private String beschreibung;
private Map<Richtungen, Bereich> nachbarn;
private List<Gegenstand> gegenstaende;
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);
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<65>nschten benachbarten Bereichs.
* @return Der gew<65>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 <20>ber den Bereich zur<75>ck.
* @return Die Informationen <20>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<Richtungen, Bereich> 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<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());
}
}
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<Richtungen, Bereich> 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<75>gende benachbarte Bereich befindet.
* @param nachbar Der hinzuzuf<75>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<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 + ".");
}
}

72
src/nogard/schritt5/Gegenstand.java
View File

@@ -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 <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";
}
public float getWeight_kg() {
return weight_kg;
}
public String getInfo() {
return "Name: " + name +
"\nBeschreibung: " + description +
"\nGewicht" + weight_kg +
"\n";
}
}

36
src/nogard/schritt5/GegenstandNichtVorhandenException.java
View File

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

27
src/nogard/schritt5/GegenstandZuSchwerException.java
View File

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

47
src/nogard/schritt5/Nahrung.java
View File

@@ -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 <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";
}
public int getNutrients() {
return nutrients;
}
public String getInfo() {
return super.getInfo() +
getNutrients();
}
}

2
src/nogard/schritt5/Program.java
View File

@@ -1,4 +1,4 @@
package nogard.schritt5;
package nogard.schritt5;
public class Program {

9
src/nogard/schritt5/Richtungen.java
View File

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

219
src/nogard/schritt5/Spiel.java
View File

@@ -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<69>end startet das Spiel.
* - Sie wertet die Befehle aus und sorgt f<>r ihre Ausf<73>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<69>end startet das Spiel.
* - Sie wertet die Befehle aus und sorgt f<>r ihre Ausf<73>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<67><72>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<73>hren.
end = ausfuehrenBefehl(befehl);
} catch (BefehlUnbekanntException e) {
System.out.println(e.getMessage());
}
}
// Endbildschirm ausgeben.
// 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) {
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<75>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<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("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.");
}
private void ausgebenStartText() {
// Begr<67><72>ungsbildschirm ausgeben.
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(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<65> nicht, was Du meinst ...");
System.out.println("Ich wei<65> nicht, was Du meinst ...");
}
}

216
src/nogard/schritt5/Spieler.java
View File

@@ -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<68>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<Gegenstand> 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<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<>();
}
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<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;
}
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 <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 + ".");
}
}
return sb.toString();
}
}

27
src/nogard/schritt5/SpielerSattException.java Normal file
View File

@@ -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<74>gt aktuell " + spieler.getFitness() + ".";
}
}

26
src/nogard/schritt5/SpielerZuSchwachException.java Normal file
View File

@@ -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<74>gt aktuell " + spieler.getFitness() + ".";
}
}

26
src/nogard/schritt5b/Befehl.java Normal file
View File

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

38
src/nogard/schritt5b/BefehlFactory.java Normal file
View File

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

14
src/nogard/schritt5b/BefehlUnbekanntException.java Normal file
View File

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

97
src/nogard/schritt5b/Bereich.java Normal file
View File

@@ -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 <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("Du bist im Bereich ");
sb.append(getBeschreibung());
sb.append("\nDeine Nachbarn sind:\n");
for (Map.Entry<Richtungen, Bereich> 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();
}
}

32
src/nogard/schritt5b/Gegenstand.java Normal file
View File

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

20
src/nogard/schritt5b/GegenstandNichtVorhandenException.java Normal file
View File

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

9
src/nogard/schritt5b/GegenstandZuSchwerException.java Normal file
View File

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

19
src/nogard/schritt5b/Nahrung.java Normal file
View File

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

9
src/nogard/schritt5b/Program.java Normal file
View File

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

5
src/nogard/schritt5b/Richtungen.java Normal file
View File

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

122
src/nogard/schritt5b/Spiel.java Normal file
View File

@@ -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<69>end startet das Spiel.
* - Sie wertet die Befehle aus und sorgt f<>r ihre Ausf<73>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<72>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<67><72>ungsbildschirm ausgeben.
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(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<65> nicht, was Du meinst ...");
}
}

46
src/nogard/schritt5b/Spieler.java Normal file
View File

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