From aa89da7ce96381df0d789146a62a3251945734f3 Mon Sep 17 00:00:00 2001 From: Janis M Date: Mon, 2 May 2022 11:58:32 +0200 Subject: [PATCH] 6 --- .idea/encodings.xml | 6 + src/nogard/schritt6/Bereich.java | 102 +++++++++ src/nogard/schritt6/Gegenstand.java | 38 ++++ src/nogard/schritt6/Nahrung.java | 21 ++ src/nogard/schritt6/Program.java | 11 + src/nogard/schritt6/Richtungen.java | 5 + src/nogard/schritt6/Spiel.java | 109 ++++++++++ src/nogard/schritt6/Spieler.java | 136 ++++++++++++ src/nogard/schritt6/commands/CommandEat.java | 23 ++ .../schritt6/commands/CommandFactory.java | 21 ++ src/nogard/schritt6/commands/CommandGo.java | 24 +++ src/nogard/schritt6/commands/CommandHelp.java | 8 + src/nogard/schritt6/commands/CommandInfo.java | 16 ++ src/nogard/schritt6/commands/CommandPut.java | 23 ++ src/nogard/schritt6/commands/CommandQuit.java | 8 + src/nogard/schritt6/commands/CommandTake.java | 24 +++ src/nogard/schritt6/commands/ICommand.java | 5 + .../exceptions/BefehlUnbekanntException.java | 14 ++ .../GegenstandNichtVorhandenException.java | 22 ++ .../GegenstandZuSchwerException.java | 20 ++ .../exceptions/SpielerSattException.java | 14 ++ .../exceptions/SpielerZuSchwachException.java | 18 ++ src/nogard/schritt6b/Befehl.java | 51 +++++ src/nogard/schritt6b/BefehlFactory.java | 61 ++++++ .../schritt6b/BefehlUnbekanntException.java | 26 +++ src/nogard/schritt6b/Bereich.java | 120 +++++++++++ src/nogard/schritt6b/Gegenstand.java | 56 +++++ .../GegenstandNichtVorhandenException.java | 26 +++ .../GegenstandZuSchwerException.java | 26 +++ src/nogard/schritt6b/Nahrung.java | 38 ++++ src/nogard/schritt6b/Program.java | 9 + src/nogard/schritt6b/Richtungen.java | 10 + src/nogard/schritt6b/Spiel.java | 199 ++++++++++++++++++ src/nogard/schritt6b/Spieler.java | 190 +++++++++++++++++ .../schritt6b/SpielerSattException.java | 27 +++ .../schritt6b/SpielerZuSchwachException.java | 26 +++ 36 files changed, 1533 insertions(+) create mode 100644 src/nogard/schritt6/Bereich.java create mode 100644 src/nogard/schritt6/Gegenstand.java create mode 100644 src/nogard/schritt6/Nahrung.java create mode 100644 src/nogard/schritt6/Program.java create mode 100644 src/nogard/schritt6/Richtungen.java create mode 100644 src/nogard/schritt6/Spiel.java create mode 100644 src/nogard/schritt6/Spieler.java create mode 100644 src/nogard/schritt6/commands/CommandEat.java create mode 100644 src/nogard/schritt6/commands/CommandFactory.java create mode 100644 src/nogard/schritt6/commands/CommandGo.java create mode 100644 src/nogard/schritt6/commands/CommandHelp.java create mode 100644 src/nogard/schritt6/commands/CommandInfo.java create mode 100644 src/nogard/schritt6/commands/CommandPut.java create mode 100644 src/nogard/schritt6/commands/CommandQuit.java create mode 100644 src/nogard/schritt6/commands/CommandTake.java create mode 100644 src/nogard/schritt6/commands/ICommand.java create mode 100644 src/nogard/schritt6/exceptions/BefehlUnbekanntException.java create mode 100644 src/nogard/schritt6/exceptions/GegenstandNichtVorhandenException.java create mode 100644 src/nogard/schritt6/exceptions/GegenstandZuSchwerException.java create mode 100644 src/nogard/schritt6/exceptions/SpielerSattException.java create mode 100644 src/nogard/schritt6/exceptions/SpielerZuSchwachException.java create mode 100644 src/nogard/schritt6b/Befehl.java create mode 100644 src/nogard/schritt6b/BefehlFactory.java create mode 100644 src/nogard/schritt6b/BefehlUnbekanntException.java create mode 100644 src/nogard/schritt6b/Bereich.java create mode 100644 src/nogard/schritt6b/Gegenstand.java create mode 100644 src/nogard/schritt6b/GegenstandNichtVorhandenException.java create mode 100644 src/nogard/schritt6b/GegenstandZuSchwerException.java create mode 100644 src/nogard/schritt6b/Nahrung.java create mode 100644 src/nogard/schritt6b/Program.java create mode 100644 src/nogard/schritt6b/Richtungen.java create mode 100644 src/nogard/schritt6b/Spiel.java create mode 100644 src/nogard/schritt6b/Spieler.java create mode 100644 src/nogard/schritt6b/SpielerSattException.java create mode 100644 src/nogard/schritt6b/SpielerZuSchwachException.java diff --git a/.idea/encodings.xml b/.idea/encodings.xml index 1dff6a6..b84cfeb 100644 --- a/.idea/encodings.xml +++ b/.idea/encodings.xml @@ -20,5 +20,11 @@ + + + + + + \ No newline at end of file diff --git a/src/nogard/schritt6/Bereich.java b/src/nogard/schritt6/Bereich.java new file mode 100644 index 0000000..08caddd --- /dev/null +++ b/src/nogard/schritt6/Bereich.java @@ -0,0 +1,102 @@ +package nogard.schritt6; + +import nogard.schritt6.Gegenstand; +import nogard.schritt6.GegenstandNichtVorhandenException; +import nogard.schritt6.Richtungen; +import nogard.schritt6.exceptions.GegenstandNichtVorhandenException; + +import java.util.HashMap; +import java.util.LinkedList; +import java.util.Map; + +/** + * Diese Klasse modelliert Bereiche.Ein Bereich kann ein Gebiet, ein Haus, ein Raum etc. sein. + * + * Jeder Bereich ist mit anderen Bereichen �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("\n\tDu bist im Bereich "); + sb.append(getBeschreibung()); + sb.append("\n\tDeine Nachbarn sind:"); + for (Map.Entry paar: nachbarn.entrySet()) { + if (paar.getValue() != null) { + sb.append("\n\t").append(paar.getKey().name()); + } + } + sb.append("\nGegenstaende:"); + for (Gegenstand g: gegenstaende) { + sb.append("\n\t").append(g.getInfo()); + } + + return sb.toString(); + } +} diff --git a/src/nogard/schritt6/Gegenstand.java b/src/nogard/schritt6/Gegenstand.java new file mode 100644 index 0000000..ae38873 --- /dev/null +++ b/src/nogard/schritt6/Gegenstand.java @@ -0,0 +1,38 @@ +package nogard.schritt6; + +public class Gegenstand { + private final String name; + private final String description; + private final double weight_kg; + + public Gegenstand(String name, String description, double weight_kg) { + this.name = name; + this.description = description; + this.weight_kg = weight_kg; + } + + public Gegenstand(String name, String description) { + this.name = name; + this.description = description; + this.weight_kg = 0; + } + + public String getName() { + return name; + } + + public String getDescription() { + return description; + } + + public double getWeight_kg() { + return weight_kg; + } + + public String getInfo() { + return "Name: " + name + + "\nBeschreibung: " + description + + "\nGewicht" + weight_kg + + "\n"; + } +} diff --git a/src/nogard/schritt6/Nahrung.java b/src/nogard/schritt6/Nahrung.java new file mode 100644 index 0000000..e6ecfae --- /dev/null +++ b/src/nogard/schritt6/Nahrung.java @@ -0,0 +1,21 @@ +package nogard.schritt6; + +import nogard.schritt6.Gegenstand; + +public class Nahrung extends Gegenstand { + private final int nutrients; + + public Nahrung(String name, String description, int nutrients) { + super(name, description); + this.nutrients = nutrients; + } + + public int getNutrients() { + return nutrients; + } + + public String getInfo() { + return super.getInfo() + + getNutrients(); + } +} diff --git a/src/nogard/schritt6/Program.java b/src/nogard/schritt6/Program.java new file mode 100644 index 0000000..c7d950c --- /dev/null +++ b/src/nogard/schritt6/Program.java @@ -0,0 +1,11 @@ +package nogard.schritt6; + +import nogard.schritt6.Spiel; + +public class Program { + + public static void main(String[] args) { + new Spiel().spielen(); + } + +} diff --git a/src/nogard/schritt6/Richtungen.java b/src/nogard/schritt6/Richtungen.java new file mode 100644 index 0000000..e8bfad2 --- /dev/null +++ b/src/nogard/schritt6/Richtungen.java @@ -0,0 +1,5 @@ +package nogard.schritt6; + +public enum Richtungen { + NORTH, EAST, SOUTH, WEST, UP, DOWN +} diff --git a/src/nogard/schritt6/Spiel.java b/src/nogard/schritt6/Spiel.java new file mode 100644 index 0000000..bf1bb65 --- /dev/null +++ b/src/nogard/schritt6/Spiel.java @@ -0,0 +1,109 @@ +package nogard.schritt6; + +import nogard.schritt6b.*; +import nogard.schritt6b.commands.CommandFactory; +import nogard.schritt6b.commands.CommandQuit; +import nogard.schritt6b.commands.ICommand; +import nogard.schritt6b.exceptions.*; + +import java.util.Scanner; + +/** + * + * Dies ist die Hauptklasse der Anwendung "Die Welt von Nogard". + * + * "Die Welt von Nogard" ist ein sehr einfaches, textbasiertes Adventure-Game, in dem sich ein Spieler durch Nogard bewegen kann. + * + * Das Spiel sollte auf jeden Fall ausgebaut werden, damit es interessanter wird! + * + * Zum Spielen muss an einer Instanz dieser Klasse die Methode "spielen()" aufgerufen werden. + * + * Diese Klasse erzeugt und initialisiert alle Objekte der Anwendung: + * - Sie legt alle Bereiche an. Anschlie�end startet das Spiel. + * - Sie wertet die Befehle aus und sorgt f�r ihre Ausf�hrung. + */ +public class Spiel { + private Spieler spieler; + + public Spiel() { + erzeugeDorf(); + } + /** + * Die Hauptmethode zum Spielen. + * L�uft bis zum Ende des Spiels in einer Schleife. + */ + public void spielen() { + ausgebenStartText(); + + // Befehle einlesen und auswerten. + Scanner scannerZeile = new Scanner(System.in); + + boolean end = false; + while (! end) { + // Eingabeaufforderung anzeigen. + System.out.print("> "); + String input = scannerZeile.nextLine(); + try { + ICommand command = CommandFactory.createCommand(spieler, input); + end = command instanceof CommandQuit; + command.execute(); + } catch (BefehlUnbekanntException e) { + System.out.println(e.getMessage()); + } + } + + // Endbildschirm ausgeben. + ausgebenEndText(); + } + + private void ausgebenEndText() { + System.out.println("Danke für dieses Spiel. Auf Wiedersehen."); + } + + private void ausgebenStartText() { + // Begr��ungsbildschirm ausgeben. + System.out.println("Willkommen in Nogard!"); + System.out.println("Entdecke die Welt von Nogard. Doch Vorsicht, überall lauern Gefahren!"); + System.out.println("Wenn du Hilfe benötigst, tippe 'help'."); + System.out.println(); + System.out.println(spieler.getInfo()); + System.out.println(spieler.getBereich().getInfo()); + } + + private void erzeugeDorf() { + // Die Bereiche erzeugen. + Bereich friedhof = new Bereich("auf einem Friedhof, umgeben von dunklen Tannen"); + Bereich wald = new Bereich("im dunklen Stadtwald von Nogard"); + Bereich taverne = new Bereich("in der Taverne, mit zwielichtigen Gestalten an der Theke"); + Bereich hexenhaus = new Bereich("im finsteren Hexenhaus"); + Bereich rathaus = new Bereich("im Rathaus von Nogard"); + Bereich weinkeller = new Bereich("Weinkeller der Taverne"); + + // Die Nachbarschaften festlegen. + taverne.setNachbar(Richtungen.NORTH, rathaus); + taverne.setNachbar(Richtungen.WEST, wald); + taverne.setNachbar(Richtungen.DOWN, weinkeller); + weinkeller.setNachbar(Richtungen.UP, taverne); + wald.setNachbar(Richtungen.NORTH, friedhof); + friedhof.setNachbar(Richtungen.SOUTH, wald); + friedhof.setNachbar(Richtungen.EAST, hexenhaus); + hexenhaus.setNachbar(Richtungen.WEST, friedhof); + + // Gegenstände Platzieren + hexenhaus.platziereGegenstand(new Gegenstand("Krug", "mit fauligem Krötenwasser", 5.0)); + hexenhaus.platziereGegenstand(new Nahrung("Froschschenkel", "mit ranziger Knoblauchbutter", 700)); + + // Erzeugen des Spielers + Scanner scannerZeile = new Scanner(System.in); + System.out.println("Spieler Erstellung\n"); + System.out.println("Name > "); + String name = scannerZeile.nextLine(); + System.out.println("Traglast > "); + float traglast = scannerZeile.nextFloat(); + System.out.println("Fitness > "); + int fitness = scannerZeile.nextInt(); + + spieler = new Spieler(name, traglast, fitness, hexenhaus); + } + +} diff --git a/src/nogard/schritt6/Spieler.java b/src/nogard/schritt6/Spieler.java new file mode 100644 index 0000000..6bba1c4 --- /dev/null +++ b/src/nogard/schritt6/Spieler.java @@ -0,0 +1,136 @@ +package nogard.schritt6; + +import nogard.schritt6.*; +import nogard.schritt6.Bereich; +import nogard.schritt6.Nahrung; +import nogard.schritt6.exceptions.GegenstandNichtVorhandenException; +import nogard.schritt6.exceptions.GegenstandZuSchwerException; +import nogard.schritt6.exceptions.SpielerSattException; +import nogard.schritt6.exceptions.SpielerZuSchwachException; + +import java.util.LinkedList; + +public class Spieler { + private static final int FITNESS_max = 5000; + private static final int VERBRAUCH_GEHEN = 500; + + private final String name; + private final float max_traglast; + private int fitness; + private final LinkedList items; + private nogard.schritt6.Bereich bereich; + + public Spieler(String name, float max_traglast, int fitness, nogard.schritt6.Bereich bereich) { + this.name = name; + this.max_traglast = max_traglast; + this.fitness = fitness; + items = new LinkedList<>(); + this.bereich = bereich; + } + + /** + * Berechnet das Gesamtgewicht aller items des Spielers. + * @return Die Auslastung des Spielers. + */ + public float getTraglast() { + float total_weight_kg = 0; + for (Gegenstand g: items) { + total_weight_kg += g.getWeight_kg(); + } + return total_weight_kg; + } + + /**! + * Sucht nach einem Gegenstand in dem derzeitigen Bereich. + * @param name Der Name des aufzunehmenden Gegenstands. + * @throws GegenstandZuSchwerException wenn das Aufnehmen des Gegenstands die Traglast überschreitet. + * @throws GegenstandNichtVorhandenException wenn der Gegenstand nicht in dem Bereich vorhanden ist + */ + public void aufnehmenGegenstand(String name) throws GegenstandZuSchwerException, GegenstandNichtVorhandenException { + Gegenstand g = bereich.sucheGegenstand(name); + + if (getTraglast() + g.getWeight_kg() > max_traglast) { + throw new GegenstandZuSchwerException(g); + } + + bereich.entferneGegenstand(g); + items.add(g); + } + + /** + * Entfernt den Gegenstand mittels des namens aus dem Inventar des spielers. + * @param name Der name des Gegenstands. + * @throws GegenstandNichtVorhandenException der Gegenstand befindet sich nicht in dem Inventar des Spielers + */ + public void ablegenGegenstand(String name) throws GegenstandNichtVorhandenException { + Gegenstand l_g = null; + for (Gegenstand g: items) { + if (g.getName().equals(name)) { + l_g = g; + break; + } + } + + if (l_g == null) { + throw new GegenstandNichtVorhandenException(name); + } + bereich.platziereGegenstand(l_g); + items.remove(l_g); + } + + /** + * Sucht nach Nahrung mithilfe des Namens in dem Bereich & isst es, wenn sie vorhanden ist + * @param name Der Name der Nahrung + * @throws GegenstandNichtVorhandenException die Nahrung ist nicht in dem Bereich vorhanden. + * @throws SpielerSattException der Spieler kann nicht mehr essen. + */ + public void essen(String name) throws GegenstandNichtVorhandenException, SpielerSattException { + Gegenstand g = bereich.sucheGegenstand(name); + + boolean is_nahrung = g instanceof nogard.schritt6b.Nahrung; + if (is_nahrung) { + nogard.schritt6b.Nahrung n = (Nahrung) g; + if (n.getNutrients() + fitness > FITNESS_max) { + throw new SpielerSattException("Spieler ist Satt"); + } + + fitness += n.getNutrients(); + } else { + throw new GegenstandNichtVorhandenException(name); + } + } + + /** + * Wechselt den Bereich + * @param b der neue Bereich. + * @throws SpielerZuSchwachException der Spieler hat nicht genug Ausdauer für den wechsel. + */ + public void geheInBereich(nogard.schritt6b.Bereich b) throws SpielerZuSchwachException { + if (fitness - VERBRAUCH_GEHEN < 0) { + throw new SpielerZuSchwachException(); + } + + fitness -= VERBRAUCH_GEHEN; + bereich = b; + } + + public Bereich getBereich() { + return bereich; + } + + public String getInfo() { + StringBuilder sb = new StringBuilder(); + sb.append("Spieler:"); + sb.append("\n\tName: ").append(name); + sb.append("\n\tFitness: ").append(fitness); + sb.append("\n\tTraglast: ").append(getTraglast()).append("/").append(max_traglast); + sb.append("\n\tItems: ["); + for (Gegenstand g: items) { + sb.append(g.getName()).append(", "); + } + sb.append("]"); + sb.append("\n\tBereich: ").append(bereich.getBeschreibung()); + + return sb.toString(); + } +} diff --git a/src/nogard/schritt6/commands/CommandEat.java b/src/nogard/schritt6/commands/CommandEat.java new file mode 100644 index 0000000..66dfb68 --- /dev/null +++ b/src/nogard/schritt6/commands/CommandEat.java @@ -0,0 +1,23 @@ +package nogard.schritt6.commands; +import nogard.schritt6b.Spieler; +import nogard.schritt6b.exceptions.GegenstandNichtVorhandenException; +import nogard.schritt6b.exceptions.SpielerSattException; + +public class CommandEat implements ICommand { + private Spieler spieler; + private String nahrung; + + public CommandEat(Spieler spieler, String nahrung) { + this.spieler = spieler; + this.nahrung = nahrung; + } + + @Override + public void execute() { + try { + spieler.essen(nahrung); + } catch (GegenstandNichtVorhandenException | SpielerSattException e) { + System.out.println(e.getMessage()); + } + } +} diff --git a/src/nogard/schritt6/commands/CommandFactory.java b/src/nogard/schritt6/commands/CommandFactory.java new file mode 100644 index 0000000..ad55590 --- /dev/null +++ b/src/nogard/schritt6/commands/CommandFactory.java @@ -0,0 +1,21 @@ +package nogard.schritt6.commands; + +import nogard.schritt6b.Richtungen; +import nogard.schritt6b.Spieler; +import nogard.schritt6b.exceptions.BefehlUnbekanntException; + +public class CommandFactory { + public static ICommand createCommand(Spieler spieler, String input) throws BefehlUnbekanntException { + String[] cmd_data = input.split(" "); + + return switch (cmd_data[0]) { + case "go" -> new CommandGo(spieler, Richtungen.valueOf(cmd_data[1].toUpperCase())); + case "take" -> new CommandTake(spieler, cmd_data[1]); + case "put" -> new CommandPut(spieler, cmd_data[1]); + case "info" -> new CommandInfo(spieler); + case "quit" -> new CommandQuit(); + case "eat" -> new CommandEat(spieler, cmd_data[1]); + default -> throw new BefehlUnbekanntException(input); + }; + } +} diff --git a/src/nogard/schritt6/commands/CommandGo.java b/src/nogard/schritt6/commands/CommandGo.java new file mode 100644 index 0000000..821bde8 --- /dev/null +++ b/src/nogard/schritt6/commands/CommandGo.java @@ -0,0 +1,24 @@ +package nogard.schritt6.commands; + +import nogard.schritt6b.Richtungen; +import nogard.schritt6b.Spieler; +import nogard.schritt6b.exceptions.SpielerZuSchwachException; + +public class CommandGo implements ICommand { + private Spieler spieler; + private Richtungen richtung; + + public CommandGo(Spieler spieler, Richtungen richtung) { + this.spieler = spieler; + this.richtung = richtung; + } + + @Override + public void execute() { + try { + spieler.geheInBereich(spieler.getBereich().getNachbar(richtung)); + } catch (SpielerZuSchwachException e) { + System.out.println(e.getMessage()); + } + } +} diff --git a/src/nogard/schritt6/commands/CommandHelp.java b/src/nogard/schritt6/commands/CommandHelp.java new file mode 100644 index 0000000..732f8c7 --- /dev/null +++ b/src/nogard/schritt6/commands/CommandHelp.java @@ -0,0 +1,8 @@ +package nogard.schritt6.commands; + +public class CommandHelp implements ICommand { + @Override + public void execute() { + System.out.println("AAAAAAAAAAAAAa"); + } +} diff --git a/src/nogard/schritt6/commands/CommandInfo.java b/src/nogard/schritt6/commands/CommandInfo.java new file mode 100644 index 0000000..25f50dc --- /dev/null +++ b/src/nogard/schritt6/commands/CommandInfo.java @@ -0,0 +1,16 @@ +package nogard.schritt6.commands; + +import nogard.schritt6b.Spieler; + +public class CommandInfo implements ICommand { + private final Spieler spieler; + + public CommandInfo(Spieler spieler) { + this.spieler = spieler; + } + + @Override + public void execute() { + System.out.println(spieler.getInfo()); + } +} diff --git a/src/nogard/schritt6/commands/CommandPut.java b/src/nogard/schritt6/commands/CommandPut.java new file mode 100644 index 0000000..948ee8a --- /dev/null +++ b/src/nogard/schritt6/commands/CommandPut.java @@ -0,0 +1,23 @@ +package nogard.schritt6.commands; + +import nogard.schritt6b.Spieler; +import nogard.schritt6b.exceptions.GegenstandNichtVorhandenException; + +public class CommandPut implements ICommand { + private Spieler spieler; + private String gegenstand; + + public CommandPut(Spieler spieler, String gegenstand) { + this.spieler = spieler; + this.gegenstand = gegenstand; + } + + @Override + public void execute() { + try { + spieler.ablegenGegenstand(gegenstand); + } catch (GegenstandNichtVorhandenException e) { + System.out.println(e.getMessage()); + } + } +} diff --git a/src/nogard/schritt6/commands/CommandQuit.java b/src/nogard/schritt6/commands/CommandQuit.java new file mode 100644 index 0000000..92e682a --- /dev/null +++ b/src/nogard/schritt6/commands/CommandQuit.java @@ -0,0 +1,8 @@ +package nogard.schritt6.commands; + +public class CommandQuit implements ICommand { + @Override + public void execute() { + + } +} diff --git a/src/nogard/schritt6/commands/CommandTake.java b/src/nogard/schritt6/commands/CommandTake.java new file mode 100644 index 0000000..969ebb3 --- /dev/null +++ b/src/nogard/schritt6/commands/CommandTake.java @@ -0,0 +1,24 @@ +package nogard.schritt6.commands; + +import nogard.schritt6b.Spieler; +import nogard.schritt6b.exceptions.GegenstandNichtVorhandenException; +import nogard.schritt6b.exceptions.GegenstandZuSchwerException; + +public class CommandTake implements ICommand { + private Spieler spieler; + private String gegenstand; + + public CommandTake(Spieler spieler, String gegenstand) { + this.spieler = spieler; + this.gegenstand = gegenstand; + } + + @Override + public void execute() { + try { + spieler.aufnehmenGegenstand(gegenstand); + } catch (GegenstandNichtVorhandenException | GegenstandZuSchwerException e) { + System.out.println(e.getMessage()); + } + } +} diff --git a/src/nogard/schritt6/commands/ICommand.java b/src/nogard/schritt6/commands/ICommand.java new file mode 100644 index 0000000..7c93d38 --- /dev/null +++ b/src/nogard/schritt6/commands/ICommand.java @@ -0,0 +1,5 @@ +package nogard.schritt6.commands; + +public interface ICommand { + void execute(); +} diff --git a/src/nogard/schritt6/exceptions/BefehlUnbekanntException.java b/src/nogard/schritt6/exceptions/BefehlUnbekanntException.java new file mode 100644 index 0000000..3145406 --- /dev/null +++ b/src/nogard/schritt6/exceptions/BefehlUnbekanntException.java @@ -0,0 +1,14 @@ +package nogard.schritt6.exceptions; + +public class BefehlUnbekanntException extends Exception { + private final String befehl; + + public BefehlUnbekanntException(String befehl) { + this.befehl = befehl; + } + + @Override + public String getMessage() { + return befehl; + } +} diff --git a/src/nogard/schritt6/exceptions/GegenstandNichtVorhandenException.java b/src/nogard/schritt6/exceptions/GegenstandNichtVorhandenException.java new file mode 100644 index 0000000..c1ee866 --- /dev/null +++ b/src/nogard/schritt6/exceptions/GegenstandNichtVorhandenException.java @@ -0,0 +1,22 @@ +package nogard.schritt6.exceptions; + +import nogard.schritt6b.Gegenstand; + +public class GegenstandNichtVorhandenException extends Exception { + private final String text; + public GegenstandNichtVorhandenException(Gegenstand g) { + StringBuilder sb = new StringBuilder(); + sb.append(g.getInfo()); + sb.append("Ist nicht in dem Bereich vorhanden."); + text = sb.toString(); + } + + public GegenstandNichtVorhandenException(String text) { + this.text = text; + } + + @Override + public String getMessage() { + return text; + } +} diff --git a/src/nogard/schritt6/exceptions/GegenstandZuSchwerException.java b/src/nogard/schritt6/exceptions/GegenstandZuSchwerException.java new file mode 100644 index 0000000..fe29c19 --- /dev/null +++ b/src/nogard/schritt6/exceptions/GegenstandZuSchwerException.java @@ -0,0 +1,20 @@ +package nogard.schritt6.exceptions; + +import nogard.schritt6b.Gegenstand; + +public class GegenstandZuSchwerException extends Exception { + private final String text; + + public GegenstandZuSchwerException(Gegenstand g) { + text = "Ist zu schwer: " + g.getDescription(); + } + + public GegenstandZuSchwerException(String text) { + this.text = text; + } + + @Override + public String getMessage() { + return text; + } +} diff --git a/src/nogard/schritt6/exceptions/SpielerSattException.java b/src/nogard/schritt6/exceptions/SpielerSattException.java new file mode 100644 index 0000000..1bdd3e9 --- /dev/null +++ b/src/nogard/schritt6/exceptions/SpielerSattException.java @@ -0,0 +1,14 @@ +package nogard.schritt6.exceptions; + +public class SpielerSattException extends Exception { + private final String text; + + public SpielerSattException(String text) { + this.text = text; + } + + @Override + public String getMessage() { + return text; + } +} diff --git a/src/nogard/schritt6/exceptions/SpielerZuSchwachException.java b/src/nogard/schritt6/exceptions/SpielerZuSchwachException.java new file mode 100644 index 0000000..969432e --- /dev/null +++ b/src/nogard/schritt6/exceptions/SpielerZuSchwachException.java @@ -0,0 +1,18 @@ +package nogard.schritt6.exceptions; + +public class SpielerZuSchwachException extends Exception { + private String text; + + public SpielerZuSchwachException() { + text = "Der Spieler ist zu schwach"; + } + + public SpielerZuSchwachException(String text) { + this.text = text; + } + + @Override + public String getMessage() { + return text; + } +} diff --git a/src/nogard/schritt6b/Befehl.java b/src/nogard/schritt6b/Befehl.java new file mode 100644 index 0000000..6f23401 --- /dev/null +++ b/src/nogard/schritt6b/Befehl.java @@ -0,0 +1,51 @@ +package nogard.schritt6b; + +/** + * 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 String befehlsWort; + private String befehlsZusatz; + + /** + * 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; + } + + /** + * Liefert das Schl�sselwort des Befehls. + * @return Das Schl�sselwort des Befehls. + */ + public String getBefehlsWort() { + return befehlsWort; + } + + /** + * Liefert den Zusatz zum Befehl. + * Wenn es keinen Befehlszusatz gibt, ist das Ergebnis 'null'. + * @return Den Zusatz zum Befehl. + */ + public String getBefehlsZusatz() { + return befehlsZusatz; + } + +} + diff --git a/src/nogard/schritt6b/BefehlFactory.java b/src/nogard/schritt6b/BefehlFactory.java new file mode 100644 index 0000000..5ffc6b2 --- /dev/null +++ b/src/nogard/schritt6b/BefehlFactory.java @@ -0,0 +1,61 @@ +package nogard.schritt6b; + +/** + * Diese Klasse erzeugt Instanzen der Klasse Befehl. + * + * Kann keine Instanz der Klasse Befehl erzeugt werden, so reagiert die Klasse mit einer entsprechenden Fehlermeldung. + * + * Besteht ein Befehl nur aus seinem Schlüsselwort, so ist der Zusatz des Befehls 'null'. + */ +public class BefehlFactory { + /** + * Erstellt eine neue Instanz eines Befehls auf Basis einer Benutzereingabe. + * @param input Die Benutzereingabe. + * @return Der erstellte Befehl. + * @throws BefehlUnbekanntException Wird geworfen, wenn keine Instanz eines Befehls erzeugt werden kann. Gründe können sein: + * - Kein Befehl eingegeben. + * - Unbekannter Befehl eingegeben. + * - Unbekannte oder nicht eingegebene Richtung beim Befehl "go". + */ + public static Befehl createBefehl(String input) throws BefehlUnbekanntException { + // Abbruch bei fehlender Eingabe. + if(input == null || input.trim().equals("")) { + throw new BefehlUnbekanntException("Du hast keinen Befehl eingegeben."); + } + // Befehl aufsplitten in die einzelnen Befehlsteile + String[] befehlArray = input.trim().split(" "); + // Auswerten des Befehlsworts + Befehl befehl = null; + String befehlWort = befehlArray[0].trim().toLowerCase(); + switch (befehlWort) { + case "go": + if (befehlArray.length >= 2) { + String richtung = befehlArray[1].trim().toLowerCase(); + // Prü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/schritt6b/BefehlUnbekanntException.java b/src/nogard/schritt6b/BefehlUnbekanntException.java new file mode 100644 index 0000000..0fd8575 --- /dev/null +++ b/src/nogard/schritt6b/BefehlUnbekanntException.java @@ -0,0 +1,26 @@ +package nogard.schritt6b; + +/** + * Die Exceptionklasse, die geworfen wird, wenn ein Befehl unbekannt ist. + */ +public class BefehlUnbekanntException extends Exception { + + private String meldung; + + /** + * Konstruktor. + * @param meldung Die Fehlermeldung. + */ + public BefehlUnbekanntException(String meldung) { + this.meldung = meldung; + } + + /* (non-Javadoc) + * @see java.lang.Throwable#getMessage() + */ + @Override + public String getMessage() { + return meldung; + } + +} diff --git a/src/nogard/schritt6b/Bereich.java b/src/nogard/schritt6b/Bereich.java new file mode 100644 index 0000000..cfa7a76 --- /dev/null +++ b/src/nogard/schritt6b/Bereich.java @@ -0,0 +1,120 @@ +package nogard.schritt6b; + +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +/** + * Diese Klasse modelliert Bereiche. Ein Bereich kann ein Gebiet, ein Haus, ein Raum etc. sein. + * + * Jeder Bereich ist mit anderen Bereichen �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. + */ +public class Bereich { + + private String beschreibung; + private Map nachbarn; + private List gegenstaende; + + /** + * Konstruktor. + * @param beschreibung Die Beschreibung des Areals. + */ + public Bereich(String beschreibung) { + this.beschreibung = beschreibung; + nachbarn = new HashMap<>(); + for (Richtungen richtung : Richtungen.values()) { + nachbarn.put(richtung, null); + } + gegenstaende = new LinkedList<>(); + } + + /** + * Liefert die Beschreibung des Bereichs. + * @return Die Beschreibung des Bereichs. + */ + public String getBeschreibung() { + return beschreibung; + } + + /** + * Liefert einen benachbarten Bereich. + * @param richtung Die Richtung des gew�nschten benachbarten Bereichs. + * @return Der gew�nschte benachbarte Bereich. + */ + public nogard.schritt6b.Bereich getNachbar(Richtungen richtung) { + return nachbarn.get(richtung); + } + + /** + * Gibt die Informationen �ber den Bereich zur�ck. + * @return Die Informationen �ber den Bereich. + */ + public String getInfo() { + 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()); + } + } + 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 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, nogard.schritt6b.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/schritt6b/Gegenstand.java b/src/nogard/schritt6b/Gegenstand.java new file mode 100644 index 0000000..00b73f3 --- /dev/null +++ b/src/nogard/schritt6b/Gegenstand.java @@ -0,0 +1,56 @@ +package nogard.schritt6b; + +/** + * Diese Klasse modelliert einen Gegenstand. + */ +public class Gegenstand { + + private String name; + private String beschreibung; + private double gewicht; + + /** + * Konstruktor. + * @param name Der Name des Gegenstandes. + * @param beschreibung Die Beschreibung des Gegenstandes. + * @param gewicht Das Gewicht des Gegenstandes in kg. + */ + public Gegenstand(String name, String beschreibung, double gewicht) { + this.name = name; + this.beschreibung = beschreibung; + this.gewicht = gewicht; + } + + /** + * Liefert den Namen des Gegenstandes. + * @return Der Name des Gegenstandes. + */ + public String getName() { + return name; + } + + /** + * Liefert die Beschreibung des Gegenstandes. + * @return Die Beschreibung des Gegenstandes. + */ + public String getBeschreibung() { + return beschreibung; + } + + /** + * Liefert das Gewicht des Gegenstandes in kg. + * @return Das Gewicht des Gegenstandes in kg. + */ + public double getGewicht() { + return gewicht; + } + + /** + * Gibt die Informationen über den Gegenstand zurück. + * @return Die Informationen über den Gegenstand. + */ + public String getInfo() { + return name + " " + beschreibung + " mit einem Gewicht von " + gewicht + " kg"; + } + +} diff --git a/src/nogard/schritt6b/GegenstandNichtVorhandenException.java b/src/nogard/schritt6b/GegenstandNichtVorhandenException.java new file mode 100644 index 0000000..7fb849a --- /dev/null +++ b/src/nogard/schritt6b/GegenstandNichtVorhandenException.java @@ -0,0 +1,26 @@ +package nogard.schritt6b; + +/** + * Die Exceptionklasse, die geworfen wird, wenn ein Gegenstand nicht vorhanden ist. + */ +public class GegenstandNichtVorhandenException extends Exception { + + private String meldung; + + /** + * Konstruktor. + * @param meldung Die Fehlermeldung. + */ + public GegenstandNichtVorhandenException(String meldung) { + this.meldung = meldung; + } + + /* (non-Javadoc) + * @see java.lang.Throwable#getMessage() + */ + @Override + public String getMessage() { + return meldung; + } + +} diff --git a/src/nogard/schritt6b/GegenstandZuSchwerException.java b/src/nogard/schritt6b/GegenstandZuSchwerException.java new file mode 100644 index 0000000..f89f66e --- /dev/null +++ b/src/nogard/schritt6b/GegenstandZuSchwerException.java @@ -0,0 +1,26 @@ +package nogard.schritt6b; + +/** + * Die Exceptionklasse, die geworfen wird, wenn ein Gegenstand nicht vorhanden ist. + */ +public class GegenstandZuSchwerException extends Exception { + + private Gegenstand gegenstand; + + /** + * Konstruktor. + * @param gegenstand Der Gegenstand. + */ + public GegenstandZuSchwerException(Gegenstand gegenstand) { + this.gegenstand = gegenstand; + } + + /* (non-Javadoc) + * @see java.lang.Throwable#getMessage() + */ + @Override + public String getMessage() { + return "Der Gegenstand " + gegenstand.getName() + " ist zu schwer."; + } + +} diff --git a/src/nogard/schritt6b/Nahrung.java b/src/nogard/schritt6b/Nahrung.java new file mode 100644 index 0000000..5de4e76 --- /dev/null +++ b/src/nogard/schritt6b/Nahrung.java @@ -0,0 +1,38 @@ +package nogard.schritt6b; + +/** + * Diese Klasse modelliert Nahrung als einen speziellen Gegenstand. + */ +public class Nahrung extends Gegenstand { + + private int naehrwert; + + /** + * Konstruktor + * @param name Der Name der Nahrung. + * @param beschreibung Die Beschreibung der Nahrung. + * @param naehrwert Der N�hrwert der Nahrung in Kilokalorien (kcal). + */ + public Nahrung(String name, String beschreibung, int naehrwert) { + super(name, beschreibung, 0); + this.naehrwert = naehrwert; + } + + /** + * Liefert den N�hrwert der Nahrung in Kilokalorien (kcal). + * @return Der N�hrwert der Nahrung in Kilokalorien (kcal). + */ + public int getNaehrwert() { + return naehrwert; + } + + /** + * Gibt die Informationen �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"; + } + +} diff --git a/src/nogard/schritt6b/Program.java b/src/nogard/schritt6b/Program.java new file mode 100644 index 0000000..c57186d --- /dev/null +++ b/src/nogard/schritt6b/Program.java @@ -0,0 +1,9 @@ +package nogard.schritt6b; + +public class Program { + + public static void main(String[] args) { + new Spiel().spielen(); + } + +} diff --git a/src/nogard/schritt6b/Richtungen.java b/src/nogard/schritt6b/Richtungen.java new file mode 100644 index 0000000..ea26a75 --- /dev/null +++ b/src/nogard/schritt6b/Richtungen.java @@ -0,0 +1,10 @@ +package nogard.schritt6b; + +/** + * Aufz�hlung aller m�glichen Richtungen + */ +public enum Richtungen { + + NORTH, EAST, SOUTH, WEST, UP, DOWN; + +} diff --git a/src/nogard/schritt6b/Spiel.java b/src/nogard/schritt6b/Spiel.java new file mode 100644 index 0000000..292f952 --- /dev/null +++ b/src/nogard/schritt6b/Spiel.java @@ -0,0 +1,199 @@ +package nogard.schritt6b; + +import java.util.Scanner; + +/** + * Dies ist die Hauptklasse der Anwendung "Die Welt von Nogard". + * + * "Die Welt von Nogard" ist ein sehr einfaches, textbasiertes Adventure-Game, + * in dem sich ein Spieler durch Nogard bewegen kann. + * + * Das Spiel sollte auf jeden Fall ausgebaut werden, damit es interessanter + * wird! + * + * Zum Spielen muss an einer Instanz dieser Klasse die Methode "spielen()" + * aufgerufen werden. + * + * Diese Klasse erzeugt und initialisiert alle Objekte der Anwendung: + * - Sie legt alle Bereiche an. Anschlie�end startet das Spiel. + * - Sie wertet die Befehle aus und sorgt f�r ihre Ausf�hrung. + */ +public class Spiel { + + private Spieler spieler; + + /** + * Konstruktor. Erstellt die Spielumgebung. + */ + public Spiel() { + erzeugeDorf(); + } + + /** + * Die Hauptmethode zum Spielen. L�uft bis zum Ende des Spiels in einer + * Schleife. + */ + public void spielen() { + // Begr��ungsbildschirm ausgeben. + ausgebenStartText(); + + // Befehle einlesen und auswerten. + Scanner scannerZeile = new Scanner(System.in); + boolean end = false; + while (!end) { + // Eingabeaufforderung anzeigen. + System.out.print("> "); + // Befehlszeile lesen. + String input = scannerZeile.nextLine(); + try { + // Befehls-Objekt erzeugen. + Befehl befehl = BefehlFactory.createBefehl(input); + // Befehl ausf�hren. + end = ausfuehrenBefehl(befehl); + } catch (BefehlUnbekanntException e) { + System.out.println(e.getMessage()); + } + } + + // 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) { + switch (befehl.getBefehlsWort()) { + case "go": + wechselBereich(befehl); + return false; + case "help": + ausgebenHilfeText(); + return false; + case "quit": + return true; + default: + ausgebenFehlerBefehl(); + return false; + } + } + + /** + * Wechseln des Bereichs. Wenn es einen benachbarten Bereich gibt, wird dorthin + * gegangen, ansonsten gibt es eine Fehlermeldung. + * + * @param befehl Der auszuf�hrende Befehl. + */ + private void wechselBereich(Befehl befehl) { + // Neuen Bereich ermitteln. + Richtungen richtung = Richtungen.valueOf(befehl.getBefehlsZusatz().toUpperCase()); + Bereich neuerBereich = spieler.getBereich().getNachbar(richtung); + // Auswertung der gefundenen Bereichs. + if (neuerBereich == null) { + System.out.println("Dort geht es nicht weiter."); + } else { + try { + spieler.gehenInBereich(neuerBereich); + } catch (SpielerZuSchwachException e) { + System.out.println(e.getMessage()); + } + System.out.println(spieler.getInfo()); + } + } + + /** + * Gibt einen Begr��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("\tgo"); + System.out.println("\tquit"); + System.out.println("\thelp"); + } + + /** + * Gibt einen Endtext auf der Konsole aus. + */ + private void ausgebenEndText() { + System.out.println("Danke f�r dieses Spiel. Auf Wiedersehen."); + } + + /** + * Gibt einen Fehlertext auf der Konsole aus, wenn der Befehl nicht verstanden + * wird. + */ + private void ausgebenFehlerBefehl() { + System.out.println("Ich wei� nicht, was Du meinst ..."); + } + +} diff --git a/src/nogard/schritt6b/Spieler.java b/src/nogard/schritt6b/Spieler.java new file mode 100644 index 0000000..16c0c0c --- /dev/null +++ b/src/nogard/schritt6b/Spieler.java @@ -0,0 +1,190 @@ +package nogard.schritt6b; + +import java.util.LinkedList; +import java.util.List; + +/** + * Diese Klasse modelliert einen Spieler. + * + * Wechselt der Spieler den Bereich, so kostet das Energie, d.h. sein Fitnesswert sinkt. + * Hat er nicht mehr genug Energie, so kann er den Wechsel nicht durchführen. + * + * Der Spieler kann Nahrung verzehren und damit Energie auftanken. + * Allerdings ist die Aufnahme von Nahrung begrenzt. + */ +public class Spieler { + + private final int VERBRAUCH_GEHEN = 500; + private final int FITNESS_Max = 5000; + + private String name; + private double traglastMax; + private int fitness; + private Bereich bereich; + private List 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<>(); + } + + /** + * 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; + } + + /** + * Liefert die maximale Traglast des Spielers. + * @return Die maximale Traglast des Spielers. + */ + public double getTraglastMax() { + return traglastMax; + } + + /** + * Liefert den Fitnesszustand des Spielers. + * @return Der Fitnesszustand des Spielers. + */ + public int getFitness() { + return fitness; + } + + /** + * Liefert den aktuellen Bereich des Spielers. + * @return Der aktuelle Bereich des Spielers. + */ + public Bereich getBereich() { + return bereich; + } + + /** + * Gibt die Informationen ü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 + "."); + } + } + +} diff --git a/src/nogard/schritt6b/SpielerSattException.java b/src/nogard/schritt6b/SpielerSattException.java new file mode 100644 index 0000000..e95d980 --- /dev/null +++ b/src/nogard/schritt6b/SpielerSattException.java @@ -0,0 +1,27 @@ +package nogard.schritt6b; + +/** + * Die Exceptionklasse, die geworfen wird, wenn eine Person satt ist. + */ +public class SpielerSattException extends Exception { + + private Spieler spieler; + + /** + * Konstruktor. + * @param spieler Der Spieler, der zu schwach ist. + */ + public SpielerSattException(Spieler spieler) { + super(); + this.spieler = spieler; + } + + /* (non-Javadoc) + * @see java.lang.Throwable#getMessage() + */ + @Override + public String getMessage() { + return spieler.getName() + ", du bist jetzt satt. Dein Fitnesswert betr�gt aktuell " + spieler.getFitness() + "."; + } + +} diff --git a/src/nogard/schritt6b/SpielerZuSchwachException.java b/src/nogard/schritt6b/SpielerZuSchwachException.java new file mode 100644 index 0000000..510276a --- /dev/null +++ b/src/nogard/schritt6b/SpielerZuSchwachException.java @@ -0,0 +1,26 @@ +package nogard.schritt6b; + +/** + * Die Exceptionklasse, die geworfen wird, wenn ein Gegenstand nicht vorhanden ist. + */ +public class SpielerZuSchwachException extends Exception { + + private Spieler spieler; + + /** + * Konstruktor. + * @param spieler Der Spieler, der zu schwach ist. + */ + public SpielerZuSchwachException(Spieler spieler) { + this.spieler = spieler; + } + + /* (non-Javadoc) + * @see java.lang.Throwable#getMessage() + */ + @Override + public String getMessage() { + return "!!! ACHTUNG !!! " + spieler.getName() + ", du bist zu schwach. Dein Fitnesswert betr�gt aktuell " + spieler.getFitness() + "."; + } + +}