diff --git a/.idea/encodings.xml b/.idea/encodings.xml new file mode 100644 index 0000000..b328ef5 --- /dev/null +++ b/.idea/encodings.xml @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/interfaces/rechteck/FlaecheRechteck.java b/src/interfaces/rechteck/FlaecheRechteck.java new file mode 100644 index 0000000..b5406b7 --- /dev/null +++ b/src/interfaces/rechteck/FlaecheRechteck.java @@ -0,0 +1,8 @@ +package interfaces.rechteck; + +public class FlaecheRechteck implements IRechnen { + @Override + public double berechne(double zahl1, double zahl2) { + return (zahl1*zahl2); + } +} diff --git a/src/interfaces/rechteck/IRechnen.java b/src/interfaces/rechteck/IRechnen.java new file mode 100644 index 0000000..f7b0e44 --- /dev/null +++ b/src/interfaces/rechteck/IRechnen.java @@ -0,0 +1,5 @@ +package interfaces.rechteck; + +public interface IRechnen { + double berechne(double zahl1, double zahl2); +} diff --git a/src/interfaces/rechteck/Programm.java b/src/interfaces/rechteck/Programm.java new file mode 100644 index 0000000..8dd3889 --- /dev/null +++ b/src/interfaces/rechteck/Programm.java @@ -0,0 +1,22 @@ +package interfaces.rechteck; + +public class Programm { + class UmfangIntern implements IRechnen{ + @Override + public double berechne(double zahl1, double zahl2) { + return (zahl1*2 + zahl2*2); + } + } + + private void doWork(){ + Rechteck rechteck = new Rechteck(2, 3); + IRechnen umfang = new UmfangIntern(); + + double ergebnis = rechteck.berechne(umfang); + } + + public static void main(String[] args) { + new Programm().doWork(); + + } +} diff --git a/src/interfaces/rechteck/Rechteck.java b/src/interfaces/rechteck/Rechteck.java new file mode 100644 index 0000000..811367b --- /dev/null +++ b/src/interfaces/rechteck/Rechteck.java @@ -0,0 +1,36 @@ +package interfaces.rechteck; + +public class Rechteck{ + private double seiteA; + private double seiteB; + + public Rechteck(double seiteA, double seiteB) { + this.seiteA = seiteA; + this.seiteB = seiteB; + } + + public void rechnen(IRechnen iRechnen){ + + } + + public double getSeiteB() { + return seiteB; + } + + public void setSeiteB(double seiteB) { + this.seiteB = seiteB; + } + + public double getSeiteA() { + return seiteA; + } + + public void setSeiteA(double seiteA) { + this.seiteA = seiteA; + } + + public double berechne(IRechnen rechnen){ + return rechnen.berechne(this.seiteA, this.seiteB); + } + +} diff --git a/src/interfaces/rechteck/UmfangRechteck.java b/src/interfaces/rechteck/UmfangRechteck.java new file mode 100644 index 0000000..03cc235 --- /dev/null +++ b/src/interfaces/rechteck/UmfangRechteck.java @@ -0,0 +1,8 @@ +package interfaces.rechteck; + +public class UmfangRechteck implements IRechnen{ + @Override + public double berechne(double zahl1, double zahl2) { + return (zahl1*2 + zahl2*2); + } +} diff --git a/src/nogard/schritt0/Bereich.java b/src/nogard/schritt0/Bereich.java new file mode 100644 index 0000000..0450ff1 --- /dev/null +++ b/src/nogard/schritt0/Bereich.java @@ -0,0 +1,85 @@ +package nogard.schritt0; + +/** + * 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 String beschreibung; + private Bereich nord; + private Bereich ost; + private Bereich sued; + private Bereich west; + + /** + * Konstruktor. + * @param beschreibung Die Beschreibung des Areals. + */ + public Bereich(String beschreibung) { + this.beschreibung = beschreibung; + nord = null; + ost = null; + sued = null; + west = null; + } + + /** + * Liefert die Beschreibung des Bereichs. + * @return Die Beschreibung des Bereichs. + */ + public String getBeschreibung() { + return beschreibung; + } + + /** + * Definiert die benachbarten Bereiche des Bereichs. + * Jede Richtung führt entweder in einen anderen Bereich oder ist 'null' (kein Ausgang). + * @param nord Der im Norden benachbarte Bereich. + * @param ost Der im Osten benachbarte Bereich. + * @param sued Der im Süden benachbarte Bereich. + * @param west Der im Westen benachbarte Bereich. + */ + public void setNachbarn(Bereich nord, Bereich ost, Bereich sued, Bereich west) { + this.nord = nord; + this.ost = ost; + this.sued = sued; + this.west = west; + } + + /** + * Liefert den im Norden benachbarten Bereich. + * @return Den im Norden benachbarten Bereich. + */ + public Bereich getNord() { + return nord; + } + + /** + * Liefert den im Osten benachbarten Bereich. + * @return Den im Osten benachbarten Bereich. + */ + public Bereich getOst() { + return ost; + } + + /** + * Liefert den im Süden benachbarten Bereich. + * @return Den im Süden benachbarten Bereich. + */ + public Bereich getSued() { + return sued; + } + + /** + * Liefert den im Westen benachbarten Bereich. + * @return Den im Westen benachbarten Bereich. + */ + public Bereich getWest() { + return west; + } + +} diff --git a/src/nogard/schritt0/Program.java b/src/nogard/schritt0/Program.java new file mode 100644 index 0000000..074438a --- /dev/null +++ b/src/nogard/schritt0/Program.java @@ -0,0 +1,9 @@ +package nogard.schritt0; + +public class Program { + + public static void main(String[] args) { + new Spiel().spielen(); + } + +} diff --git a/src/nogard/schritt0/Spiel.java b/src/nogard/schritt0/Spiel.java new file mode 100644 index 0000000..fdb65d5 --- /dev/null +++ b/src/nogard/schritt0/Spiel.java @@ -0,0 +1,148 @@ +package nogard.schritt0; + +import java.util.Scanner; + +/** + * Dies ist die Hauptklasse der Anwendung "Die Welt von Nogard". + * + * "Die Welt von Nogard" ist ein sehr einfaches, textbasiertes Adventure-Game, in dem sich ein Spieler durch Nogard bewegen kann. + * + * Das Spiel sollte auf jeden Fall ausgebaut werden, damit es interessanter wird! + * + * Zum Spielen muss an einer Instanz dieser Klasse die Methode "spielen()" aufgerufen werden. + * + * Diese Klasse erzeugt und initialisiert alle Objekte der Anwendung: + * - Sie legt alle Bereiche an. Anschließend startet das Spiel. + * - Sie wertet die Befehle aus und sorgt für ihre Ausführung. + */ +public class Spiel { + private Bereich aktiverBereich; + + /** + * Die Hauptmethode zum Spielen. + * Läuft bis zum Ende des Spiels in einer Schleife. + */ + public void spielen() { + // 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"); + + // Die Nachbarschaften festlegen. + friedhof.setNachbarn(null, null, hexenhaus, null); + wald.setNachbarn(hexenhaus, taverne, null, null); + taverne.setNachbarn(rathaus, null, null, wald); + hexenhaus.setNachbarn(friedhof, rathaus, null, null); + rathaus.setNachbarn(null, null, taverne, hexenhaus); + + // Das Spielt startet im Wald. + aktiverBereich = wald; + + // 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("Du befindest dich " + aktiverBereich.getBeschreibung() + "."); + System.out.println("Du kannst gehen nach:"); + if(aktiverBereich.getNord() != null) { + System.out.println("\tNorden."); + } + if(aktiverBereich.getOst() != null) { + System.out.println("\tOsten."); + } + if(aktiverBereich.getSued() != null) { + System.out.println("\tSüden."); + } + if(aktiverBereich.getWest() != null) { + System.out.println("\tWesten."); + } + + // 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(); + // Befehl interpretieren. + String[] befehl = input.trim().split(" "); + // Abbruch bei fehlender Eingabe. + if(befehl.length == 0) { + System.out.println("Ich weiß nicht, was Du meinst ..."); + end = false; + } + else { + // Auswerten des Befehls. + String befehlWort = befehl[0].trim(); + if (befehlWort.equalsIgnoreCase("go")) { + if (befehl.length < 2) { + System.out.println("Wohin möchtest Du gehen?"); + } + else { + String richtung = befehl[1].trim(); + Bereich neuerBereich; + if(richtung.equalsIgnoreCase("north")) { + neuerBereich = aktiverBereich.getNord(); + } + else if(richtung.equalsIgnoreCase("east")) { + neuerBereich = aktiverBereich.getOst(); + } + else if(richtung.equalsIgnoreCase("south")) { + neuerBereich = aktiverBereich.getSued(); + } + else if(richtung.equalsIgnoreCase("west")) { + neuerBereich = aktiverBereich.getWest(); + } + else { + neuerBereich = null; + } + // Auswertung der gefundenen Bereichs. + if (neuerBereich == null) { + System.out.println("Dort geht es nicht weiter."); + } + else { + aktiverBereich = neuerBereich; + System.out.println("Du befindest dich " + aktiverBereich.getBeschreibung() + "."); + System.out.println("Du kannst gehen nach:"); + if(aktiverBereich.getNord() != null) { + System.out.println("\tNorden."); + } + if(aktiverBereich.getOst() != null) { + System.out.println("\tOsten."); + } + if(aktiverBereich.getSued() != null) { + System.out.println("\tSüden."); + } + if(aktiverBereich.getWest() != null) { + System.out.println("\tWesten."); + } + } + } + end = false; + } + else if (befehlWort.equalsIgnoreCase("help")) { + 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"); + end = false; + } + else if (befehlWort.equalsIgnoreCase("quit")) { + end = true; + } + else { + System.out.println("Ich weiß nicht, was Du meinst ..."); + end = false; + } + } + } + + // Endbildschirm ausgeben. + System.out.println("Danke für dieses Spiel. Auf Wiedersehen."); + } +} diff --git a/src/nogard/schritt1/Bereich.java b/src/nogard/schritt1/Bereich.java new file mode 100644 index 0000000..152d16d --- /dev/null +++ b/src/nogard/schritt1/Bereich.java @@ -0,0 +1,85 @@ +package nogard.schritt1; + +/** + * 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 String beschreibung; + private Bereich nord; + private Bereich ost; + private Bereich sued; + private Bereich west; + + /** + * Konstruktor. + * @param beschreibung Die Beschreibung des Areals. + */ + public Bereich(String beschreibung) { + this.beschreibung = beschreibung; + nord = null; + ost = null; + sued = null; + west = null; + } + + /** + * Liefert die Beschreibung des Bereichs. + * @return Die Beschreibung des Bereichs. + */ + public String getBeschreibung() { + return beschreibung; + } + + /** + * Definiert die benachbarten Bereiche des Bereichs. + * Jede Richtung führt entweder in einen anderen Bereich oder ist 'null' (kein Ausgang). + * @param nord Der im Norden benachbarte Bereich. + * @param ost Der im Osten benachbarte Bereich. + * @param sued Der im Süden benachbarte Bereich. + * @param west Der im Westen benachbarte Bereich. + */ + public void setNachbarn(Bereich nord, Bereich ost, Bereich sued, Bereich west) { + this.nord = nord; + this.ost = ost; + this.sued = sued; + this.west = west; + } + + /** + * Liefert den im Norden benachbarten Bereich. + * @return Den im Norden benachbarten Bereich. + */ + public Bereich getNord() { + return nord; + } + + /** + * Liefert den im Osten benachbarten Bereich. + * @return Den im Osten benachbarten Bereich. + */ + public Bereich getOst() { + return ost; + } + + /** + * Liefert den im Süden benachbarten Bereich. + * @return Den im Süden benachbarten Bereich. + */ + public Bereich getSued() { + return sued; + } + + /** + * Liefert den im Westen benachbarten Bereich. + * @return Den im Westen benachbarten Bereich. + */ + public Bereich getWest() { + return west; + } + +} diff --git a/src/nogard/schritt1/Program.java b/src/nogard/schritt1/Program.java new file mode 100644 index 0000000..6f1d256 --- /dev/null +++ b/src/nogard/schritt1/Program.java @@ -0,0 +1,9 @@ +package nogard.schritt1; + +public class Program { + + public static void main(String[] args) { + new Spiel().spielen(); + } + +} diff --git a/src/nogard/schritt1/Spiel.java b/src/nogard/schritt1/Spiel.java new file mode 100644 index 0000000..c894ea0 --- /dev/null +++ b/src/nogard/schritt1/Spiel.java @@ -0,0 +1,162 @@ +package nogard.schritt1; + +import java.util.Scanner; + +/** + * Dies ist die Hauptklasse der Anwendung "Die Welt von Nogard". + * + * "Die Welt von Nogard" ist ein sehr einfaches, textbasiertes Adventure-Game, in dem sich ein Spieler durch Nogard bewegen kann. + * + * Das Spiel sollte auf jeden Fall ausgebaut werden, damit es interessanter wird! + * + * Zum Spielen muss an einer Instanz dieser Klasse die Methode "spielen()" aufgerufen werden. + * + * Diese Klasse erzeugt und initialisiert alle Objekte der Anwendung: + * - Sie legt alle Bereiche an. Anschließend startet das Spiel. + * - Sie wertet die Befehle aus und sorgt für ihre Ausführung. + */ +public class Spiel { + private Bereich aktiverBereich; + + /** + * Die Hauptmethode zum Spielen. + * Läuft bis zum Ende des Spiels in einer Schleife. + */ + public void spielen() { + erzeugeDorf(); + + ausgebenStartText(); + ausgebenBereichsInfo(); + + // 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(); + // Befehl interpretieren. + String[] befehl = input.trim().split(" "); + // Abbruch bei fehlender Eingabe. + if(befehl.length == 0) { + System.out.println("Ich weiß nicht, was Du meinst ..."); + end = false; + } + else { + // Auswerten des Befehls. + String befehlWort = befehl[0].trim(); + if (befehlWort.equalsIgnoreCase("go")) { + wechselBereich(befehl); + end = false; + } + else if (befehlWort.equalsIgnoreCase("help")) { + ausgebenHilfeText(); + end = false; + } + else if (befehlWort.equalsIgnoreCase("quit")) { + end = true; + } + else { + System.out.println("Ich weiß nicht, was Du meinst ..."); + end = false; + } + } + } + ausgebenEndText(); + + } + + private void wechselBereich(String[] befehl) { + if (befehl.length < 2) { + System.out.println("Wohin möchtest Du gehen?"); + } + else { + String richtung = befehl[1].trim(); + Bereich neuerBereich; + if(richtung.equalsIgnoreCase("north")) { + neuerBereich = aktiverBereich.getNord(); + } + else if(richtung.equalsIgnoreCase("east")) { + neuerBereich = aktiverBereich.getOst(); + } + else if(richtung.equalsIgnoreCase("south")) { + neuerBereich = aktiverBereich.getSued(); + } + else if(richtung.equalsIgnoreCase("west")) { + neuerBereich = aktiverBereich.getWest(); + } + else { + neuerBereich = null; + } + // Auswertung der gefundenen Bereichs. + if (neuerBereich == null) { + System.out.println("Dort geht es nicht weiter."); + } + else { + aktiverBereich = neuerBereich; + ausgebenBereichsInfo(); + } + } + } + + + private void ausgebenHilfeText() { + System.out.println("Du irrst in Nogard herum."); + System.out.println("Dir stehen folgende Befehle zur Verfügung:"); + System.out.println("\tgo"); + System.out.println("\tquit"); + System.out.println("\thelp"); + } + + private void 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"); + + // Die Nachbarschaften festlegen. + friedhof.setNachbarn(null, null, hexenhaus, null); + wald.setNachbarn(hexenhaus, taverne, null, null); + taverne.setNachbarn(rathaus, null, null, wald); + hexenhaus.setNachbarn(friedhof, rathaus, null, null); + rathaus.setNachbarn(null, null, taverne, hexenhaus); + + // Das Spielt startet im Wald. + aktiverBereich = wald; + } + + private void ausgebenEndText() { + // Endbildschirm ausgeben. + 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(); + } + + + private void ausgebenBereichsInfo() { + System.out.println("Du befindest dich " + aktiverBereich.getBeschreibung() + "."); + System.out.println("Du kannst gehen nach:"); + if(aktiverBereich.getNord() != null) { + System.out.println("\tNorden."); + } + if(aktiverBereich.getOst() != null) { + System.out.println("\tOsten."); + } + if(aktiverBereich.getSued() != null) { + System.out.println("\tSüden."); + } + if(aktiverBereich.getWest() != null) { + System.out.println("\tWesten."); + } + } +} diff --git a/src/nogard/schritt2/Befehl.java b/src/nogard/schritt2/Befehl.java new file mode 100644 index 0000000..79b3f8a --- /dev/null +++ b/src/nogard/schritt2/Befehl.java @@ -0,0 +1,27 @@ +package nogard.schritt2; + +public class Befehl{ + private String befehlsWort; + private String befehlsSatz; + + + + public Befehl(String befehlsWort) { + this.befehlsWort = befehlsWort; + this.befehlsSatz = null; + } + + + public Befehl(String befehlsWort, String befehlsSatz) { + this.befehlsWort = befehlsWort; + this.befehlsSatz = befehlsSatz; + } + + public String getBefehlsSatz() { + return befehlsSatz; + } + + public String getBefehlsWort() { + return befehlsWort; + } +} diff --git a/src/nogard/schritt2/BefehlFactory.java b/src/nogard/schritt2/BefehlFactory.java new file mode 100644 index 0000000..be5600d --- /dev/null +++ b/src/nogard/schritt2/BefehlFactory.java @@ -0,0 +1,39 @@ +package nogard.schritt2; + +public class BefehlFactory { + public static Befehl createBefehl(String eingabe) throws BefehlUnbekanntException{ + + if(eingabe.length() > 0){ + String[] befehl = eingabe.trim().split(" "); + befehl[0] = befehl[0].toLowerCase(); + + if(befehl.length > 1){ + befehl[1] = befehl[1].toLowerCase(); + } + + + + switch (befehl[0]){ + case "go": return goBefehl(befehl); + case "help": return helpBefehl(befehl); + case "quit": return quitBefehl(befehl); + default: throw new BefehlUnbekanntException(); + } + + }else{ + throw new BefehlUnbekanntException(); + } + } + + private static Befehl quitBefehl(String[] befehl) { + return new Befehl(befehl[0]); + } + + private static Befehl helpBefehl(String[] befehl) { + return new Befehl(befehl[0]); + } + + private static Befehl goBefehl(String[] befehl) { + return new Befehl(befehl[0], befehl[1]); + } +} diff --git a/src/nogard/schritt2/BefehlUnbekanntException.java b/src/nogard/schritt2/BefehlUnbekanntException.java new file mode 100644 index 0000000..4924c42 --- /dev/null +++ b/src/nogard/schritt2/BefehlUnbekanntException.java @@ -0,0 +1,10 @@ +package nogard.schritt2; + +public class BefehlUnbekanntException extends Exception { + private String message = "Befehl nicht bekannt"; + + @Override + public String getMessage() { + return message; + } +} diff --git a/src/nogard/schritt2/Bereich.java b/src/nogard/schritt2/Bereich.java new file mode 100644 index 0000000..330994c --- /dev/null +++ b/src/nogard/schritt2/Bereich.java @@ -0,0 +1,85 @@ +package nogard.schritt2; + +/** + * 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 String beschreibung; + private Bereich nord; + private Bereich ost; + private Bereich sued; + private Bereich west; + + /** + * Konstruktor. + * @param beschreibung Die Beschreibung des Areals. + */ + public Bereich(String beschreibung) { + this.beschreibung = beschreibung; + nord = null; + ost = null; + sued = null; + west = null; + } + + /** + * Liefert die Beschreibung des Bereichs. + * @return Die Beschreibung des Bereichs. + */ + public String getBeschreibung() { + return beschreibung; + } + + /** + * Definiert die benachbarten Bereiche des Bereichs. + * Jede Richtung führt entweder in einen anderen Bereich oder ist 'null' (kein Ausgang). + * @param nord Der im Norden benachbarte Bereich. + * @param ost Der im Osten benachbarte Bereich. + * @param sued Der im Süden benachbarte Bereich. + * @param west Der im Westen benachbarte Bereich. + */ + public void setNachbarn(Bereich nord, Bereich ost, Bereich sued, Bereich west) { + this.nord = nord; + this.ost = ost; + this.sued = sued; + this.west = west; + } + + /** + * Liefert den im Norden benachbarten Bereich. + * @return Den im Norden benachbarten Bereich. + */ + public Bereich getNord() { + return nord; + } + + /** + * Liefert den im Osten benachbarten Bereich. + * @return Den im Osten benachbarten Bereich. + */ + public Bereich getOst() { + return ost; + } + + /** + * Liefert den im Süden benachbarten Bereich. + * @return Den im Süden benachbarten Bereich. + */ + public Bereich getSued() { + return sued; + } + + /** + * Liefert den im Westen benachbarten Bereich. + * @return Den im Westen benachbarten Bereich. + */ + public Bereich getWest() { + return west; + } + +} diff --git a/src/nogard/schritt2/Program.java b/src/nogard/schritt2/Program.java new file mode 100644 index 0000000..51efbb8 --- /dev/null +++ b/src/nogard/schritt2/Program.java @@ -0,0 +1,9 @@ +package nogard.schritt2; + +public class Program { + + public static void main(String[] args) { + new Spiel().spielen(); + } + +} diff --git a/src/nogard/schritt2/Spiel.java b/src/nogard/schritt2/Spiel.java new file mode 100644 index 0000000..b1f07e5 --- /dev/null +++ b/src/nogard/schritt2/Spiel.java @@ -0,0 +1,162 @@ +package nogard.schritt2; + +import java.util.Scanner; + +/** + * Dies ist die Hauptklasse der Anwendung "Die Welt von Nogard". + * + * "Die Welt von Nogard" ist ein sehr einfaches, textbasiertes Adventure-Game, in dem sich ein Spieler durch Nogard bewegen kann. + * + * Das Spiel sollte auf jeden Fall ausgebaut werden, damit es interessanter wird! + * + * Zum Spielen muss an einer Instanz dieser Klasse die Methode "spielen()" aufgerufen werden. + * + * Diese Klasse erzeugt und initialisiert alle Objekte der Anwendung: + * - Sie legt alle Bereiche an. Anschließend startet das Spiel. + * - Sie wertet die Befehle aus und sorgt für ihre Ausführung. + */ +public class Spiel { + private Bereich aktiverBereich; + + /** + * Die Hauptmethode zum Spielen. + * Läuft bis zum Ende des Spiels in einer Schleife. + */ + public void spielen() { + erzeugeDorf(); + + ausgebenStartText(); + ausgebenBereichsInfo(); + + // 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(); + // Befehl interpretieren. + String[] befehl = input.trim().split(" "); + // Abbruch bei fehlender Eingabe. + if(befehl.length == 0) { + System.out.println("Ich weiß nicht, was Du meinst ..."); + end = false; + } + else { + // Auswerten des Befehls. + String befehlWort = befehl[0].trim(); + if (befehlWort.equalsIgnoreCase("go")) { + wechselBereich(befehl); + end = false; + } + else if (befehlWort.equalsIgnoreCase("help")) { + ausgebenHilfeText(); + end = false; + } + else if (befehlWort.equalsIgnoreCase("quit")) { + end = true; + } + else { + System.out.println("Ich weiß nicht, was Du meinst ..."); + end = false; + } + } + } + ausgebenEndText(); + + } + + private void wechselBereich(String[] befehl) { + if (befehl.length < 2) { + System.out.println("Wohin möchtest Du gehen?"); + } + else { + String richtung = befehl[1].trim(); + Bereich neuerBereich; + if(richtung.equalsIgnoreCase("north")) { + neuerBereich = aktiverBereich.getNord(); + } + else if(richtung.equalsIgnoreCase("east")) { + neuerBereich = aktiverBereich.getOst(); + } + else if(richtung.equalsIgnoreCase("south")) { + neuerBereich = aktiverBereich.getSued(); + } + else if(richtung.equalsIgnoreCase("west")) { + neuerBereich = aktiverBereich.getWest(); + } + else { + neuerBereich = null; + } + // Auswertung der gefundenen Bereichs. + if (neuerBereich == null) { + System.out.println("Dort geht es nicht weiter."); + } + else { + aktiverBereich = neuerBereich; + ausgebenBereichsInfo(); + } + } + } + + + private void ausgebenHilfeText() { + System.out.println("Du irrst in Nogard herum."); + System.out.println("Dir stehen folgende Befehle zur Verfügung:"); + System.out.println("\tgo"); + System.out.println("\tquit"); + System.out.println("\thelp"); + } + + private void 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"); + + // Die Nachbarschaften festlegen. + friedhof.setNachbarn(null, null, hexenhaus, null); + wald.setNachbarn(hexenhaus, taverne, null, null); + taverne.setNachbarn(rathaus, null, null, wald); + hexenhaus.setNachbarn(friedhof, rathaus, null, null); + rathaus.setNachbarn(null, null, taverne, hexenhaus); + + // Das Spielt startet im Wald. + aktiverBereich = wald; + } + + private void ausgebenEndText() { + // Endbildschirm ausgeben. + 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(); + } + + + private void ausgebenBereichsInfo() { + System.out.println("Du befindest dich " + aktiverBereich.getBeschreibung() + "."); + System.out.println("Du kannst gehen nach:"); + if(aktiverBereich.getNord() != null) { + System.out.println("\tNorden."); + } + if(aktiverBereich.getOst() != null) { + System.out.println("\tOsten."); + } + if(aktiverBereich.getSued() != null) { + System.out.println("\tSüden."); + } + if(aktiverBereich.getWest() != null) { + System.out.println("\tWesten."); + } + } +} diff --git a/src/nogard/schritt3/Befehl.java b/src/nogard/schritt3/Befehl.java new file mode 100644 index 0000000..6fb8f08 --- /dev/null +++ b/src/nogard/schritt3/Befehl.java @@ -0,0 +1,27 @@ +package nogard.schritt3; + +public class Befehl{ + private String befehlsWort; + private String befehlsSatz; + + + + public Befehl(String befehlsWort) { + this.befehlsWort = befehlsWort; + this.befehlsSatz = null; + } + + + public Befehl(String befehlsWort, String befehlsSatz) { + this.befehlsWort = befehlsWort; + this.befehlsSatz = befehlsSatz; + } + + public String getBefehlsSatz() { + return befehlsSatz; + } + + public String getBefehlsWort() { + return befehlsWort; + } +} diff --git a/src/nogard/schritt3/BefehlFactory.java b/src/nogard/schritt3/BefehlFactory.java new file mode 100644 index 0000000..de0ad62 --- /dev/null +++ b/src/nogard/schritt3/BefehlFactory.java @@ -0,0 +1,39 @@ +package nogard.schritt3; + +public class BefehlFactory { + public static Befehl createBefehl(String eingabe) throws BefehlUnbekanntException { + + if(eingabe.length() > 0){ + String[] befehl = eingabe.trim().split(" "); + befehl[0] = befehl[0].toLowerCase(); + + if(befehl.length > 1){ + befehl[1] = befehl[1].toLowerCase(); + } + + + + switch (befehl[0]){ + case "go": return goBefehl(befehl); + case "help": return helpBefehl(befehl); + case "quit": return quitBefehl(befehl); + default: throw new BefehlUnbekanntException(); + } + + }else{ + throw new BefehlUnbekanntException(); + } + } + + private static Befehl quitBefehl(String[] befehl) { + return new Befehl(befehl[0]); + } + + private static Befehl helpBefehl(String[] befehl) { + return new Befehl(befehl[0]); + } + + private static Befehl goBefehl(String[] befehl) { + return new Befehl(befehl[0], befehl[1]); + } +} diff --git a/src/nogard/schritt3/BefehlUnbekanntException.java b/src/nogard/schritt3/BefehlUnbekanntException.java new file mode 100644 index 0000000..55feb06 --- /dev/null +++ b/src/nogard/schritt3/BefehlUnbekanntException.java @@ -0,0 +1,10 @@ +package nogard.schritt3; + +public class BefehlUnbekanntException extends Exception { + private String message = "Befehl nicht bekannt"; + + @Override + public String getMessage() { + return message; + } +} diff --git a/src/nogard/schritt3/Bereich.java b/src/nogard/schritt3/Bereich.java new file mode 100644 index 0000000..c532cd9 --- /dev/null +++ b/src/nogard/schritt3/Bereich.java @@ -0,0 +1,101 @@ +package nogard.schritt3; + +/** + * 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 String beschreibung; + private Bereich nord; + private Bereich ost; + private Bereich sued; + private Bereich west; + + /** + * Konstruktor. + * @param beschreibung Die Beschreibung des Areals. + */ + public Bereich(String beschreibung) { + this.beschreibung = beschreibung; + nord = null; + ost = null; + sued = null; + west = null; + } + + public void getInfo(){ + System.out.println("Du befindest dich " + this.getBeschreibung() + "."); + System.out.println("Du kannst gehen nach:"); + if(this.getNord() != null) { + System.out.println("\tNorden."); + } + if(this.getOst() != null) { + System.out.println("\tOsten."); + } + if(this.getSued() != null) { + System.out.println("\tSüden."); + } + if(this.getWest() != null) { + System.out.println("\tWesten."); + } + } + /** + * Liefert die Beschreibung des Bereichs. + * @return Die Beschreibung des Bereichs. + */ + public String getBeschreibung() { + return beschreibung; + } + + /** + * Definiert die benachbarten Bereiche des Bereichs. + * Jede Richtung führt entweder in einen anderen Bereich oder ist 'null' (kein Ausgang). + * @param nord Der im Norden benachbarte Bereich. + * @param ost Der im Osten benachbarte Bereich. + * @param sued Der im Süden benachbarte Bereich. + * @param west Der im Westen benachbarte Bereich. + */ + public void setNachbarn(Bereich nord, Bereich ost, Bereich sued, Bereich west) { + this.nord = nord; + this.ost = ost; + this.sued = sued; + this.west = west; + } + + /** + * Liefert den im Norden benachbarten Bereich. + * @return Den im Norden benachbarten Bereich. + */ + public Bereich getNord() { + return nord; + } + + /** + * Liefert den im Osten benachbarten Bereich. + * @return Den im Osten benachbarten Bereich. + */ + public Bereich getOst() { + return ost; + } + + /** + * Liefert den im Süden benachbarten Bereich. + * @return Den im Süden benachbarten Bereich. + */ + public Bereich getSued() { + return sued; + } + + /** + * Liefert den im Westen benachbarten Bereich. + * @return Den im Westen benachbarten Bereich. + */ + public Bereich getWest() { + return west; + } + +} diff --git a/src/nogard/schritt3/Program.java b/src/nogard/schritt3/Program.java new file mode 100644 index 0000000..ba6e965 --- /dev/null +++ b/src/nogard/schritt3/Program.java @@ -0,0 +1,9 @@ +package nogard.schritt3; + +public class Program { + + public static void main(String[] args) { + new Spiel().spielen(); + } + +} diff --git a/src/nogard/schritt3/Spiel.java b/src/nogard/schritt3/Spiel.java new file mode 100644 index 0000000..163e55c --- /dev/null +++ b/src/nogard/schritt3/Spiel.java @@ -0,0 +1,144 @@ +package nogard.schritt3; + +import java.util.Scanner; + +/** + * Dies ist die Hauptklasse der Anwendung "Die Welt von Nogard". + * + * "Die Welt von Nogard" ist ein sehr einfaches, textbasiertes Adventure-Game, in dem sich ein Spieler durch Nogard bewegen kann. + * + * Das Spiel sollte auf jeden Fall ausgebaut werden, damit es interessanter wird! + * + * Zum Spielen muss an einer Instanz dieser Klasse die Methode "spielen()" aufgerufen werden. + * + * Diese Klasse erzeugt und initialisiert alle Objekte der Anwendung: + * - Sie legt alle Bereiche an. Anschließend startet das Spiel. + * - Sie wertet die Befehle aus und sorgt für ihre Ausführung. + */ +public class Spiel { + private Bereich aktiverBereich; + + /** + * Die Hauptmethode zum Spielen. + * Läuft bis zum Ende des Spiels in einer Schleife. + */ + public void spielen() { + erzeugeDorf(); + + ausgebenStartText(); + aktiverBereich.getInfo(); + + // 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(); + // Befehl interpretieren. + String[] befehl = input.trim().split(" "); + // Abbruch bei fehlender Eingabe. + if(befehl.length == 0) { + System.out.println("Ich weiß nicht, was Du meinst ..."); + end = false; + } + else { + // Auswerten des Befehls. + String befehlWort = befehl[0].trim(); + if (befehlWort.equalsIgnoreCase("go")) { + wechselBereich(befehl); + end = false; + } + else if (befehlWort.equalsIgnoreCase("help")) { + ausgebenHilfeText(); + end = false; + } + else if (befehlWort.equalsIgnoreCase("quit")) { + end = true; + } + else { + System.out.println("Ich weiß nicht, was Du meinst ..."); + end = false; + } + } + } + ausgebenEndText(); + + } + + private void wechselBereich(String[] befehl) { + if (befehl.length < 2) { + System.out.println("Wohin möchtest Du gehen?"); + } + else { + String richtung = befehl[1].trim(); + Bereich neuerBereich; + if(richtung.equalsIgnoreCase("north")) { + neuerBereich = aktiverBereich.getNord(); + } + else if(richtung.equalsIgnoreCase("east")) { + neuerBereich = aktiverBereich.getOst(); + } + else if(richtung.equalsIgnoreCase("south")) { + neuerBereich = aktiverBereich.getSued(); + } + else if(richtung.equalsIgnoreCase("west")) { + neuerBereich = aktiverBereich.getWest(); + } + else { + neuerBereich = null; + } + // Auswertung der gefundenen Bereichs. + if (neuerBereich == null) { + System.out.println("Dort geht es nicht weiter."); + } + else { + aktiverBereich = neuerBereich; + aktiverBereich.getInfo(); + } + } + } + + + private void ausgebenHilfeText() { + System.out.println("Du irrst in Nogard herum."); + System.out.println("Dir stehen folgende Befehle zur Verfügung:"); + System.out.println("\tgo"); + System.out.println("\tquit"); + System.out.println("\thelp"); + } + + private void 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"); + + // Die Nachbarschaften festlegen. + friedhof.setNachbarn(null, null, hexenhaus, null); + wald.setNachbarn(hexenhaus, taverne, null, null); + taverne.setNachbarn(rathaus, null, null, wald); + hexenhaus.setNachbarn(friedhof, rathaus, null, null); + rathaus.setNachbarn(null, null, taverne, hexenhaus); + + // Das Spielt startet im Wald. + aktiverBereich = wald; + } + + private void ausgebenEndText() { + // Endbildschirm ausgeben. + 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(); + } +} diff --git a/src/nogard/schritt4/Befehl.java b/src/nogard/schritt4/Befehl.java new file mode 100644 index 0000000..1e3b0e9 --- /dev/null +++ b/src/nogard/schritt4/Befehl.java @@ -0,0 +1,27 @@ +package nogard.schritt4; + +public class Befehl{ + private String befehlsWort; + private String befehlsSatz; + + + + public Befehl(String befehlsWort) { + this.befehlsWort = befehlsWort; + this.befehlsSatz = null; + } + + + public Befehl(String befehlsWort, String befehlsSatz) { + this.befehlsWort = befehlsWort; + this.befehlsSatz = befehlsSatz; + } + + public String getBefehlsSatz() { + return befehlsSatz; + } + + public String getBefehlsWort() { + return befehlsWort; + } +} diff --git a/src/nogard/schritt4/BefehlFactory.java b/src/nogard/schritt4/BefehlFactory.java new file mode 100644 index 0000000..7fa90e9 --- /dev/null +++ b/src/nogard/schritt4/BefehlFactory.java @@ -0,0 +1,39 @@ +package nogard.schritt4; + +public class BefehlFactory { + public static Befehl createBefehl(String eingabe) throws BefehlUnbekanntException { + + if(eingabe.length() > 0){ + String[] befehl = eingabe.trim().split(" "); + befehl[0] = befehl[0].toLowerCase(); + + if(befehl.length > 1){ + befehl[1] = befehl[1].toLowerCase(); + } + + + + switch (befehl[0]){ + case "go": return goBefehl(befehl); + case "help": return helpBefehl(befehl); + case "quit": return quitBefehl(befehl); + default: throw new BefehlUnbekanntException(); + } + + }else{ + throw new BefehlUnbekanntException(); + } + } + + private static Befehl quitBefehl(String[] befehl) { + return new Befehl(befehl[0]); + } + + private static Befehl helpBefehl(String[] befehl) { + return new Befehl(befehl[0]); + } + + private static Befehl goBefehl(String[] befehl) { + return new Befehl(befehl[0], befehl[1]); + } +} diff --git a/src/nogard/schritt4/BefehlUnbekanntException.java b/src/nogard/schritt4/BefehlUnbekanntException.java new file mode 100644 index 0000000..624c6e6 --- /dev/null +++ b/src/nogard/schritt4/BefehlUnbekanntException.java @@ -0,0 +1,10 @@ +package nogard.schritt4; + +public class BefehlUnbekanntException extends Exception { + private String message = "Befehl nicht bekannt"; + + @Override + public String getMessage() { + return message; + } +} diff --git a/src/nogard/schritt4/Bereich.java b/src/nogard/schritt4/Bereich.java new file mode 100644 index 0000000..3b272ed --- /dev/null +++ b/src/nogard/schritt4/Bereich.java @@ -0,0 +1,101 @@ +package nogard.schritt4; + +/** + * 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 String beschreibung; + private Bereich nord; + private Bereich ost; + private Bereich sued; + private Bereich west; + + /** + * Konstruktor. + * @param beschreibung Die Beschreibung des Areals. + */ + public Bereich(String beschreibung) { + this.beschreibung = beschreibung; + nord = null; + ost = null; + sued = null; + west = null; + } + + public void getInfo(){ + System.out.println("Du befindest dich " + this.getBeschreibung() + "."); + System.out.println("Du kannst gehen nach:"); + if(this.getNord() != null) { + System.out.println("\tNorden."); + } + if(this.getOst() != null) { + System.out.println("\tOsten."); + } + if(this.getSued() != null) { + System.out.println("\tSüden."); + } + if(this.getWest() != null) { + System.out.println("\tWesten."); + } + } + /** + * Liefert die Beschreibung des Bereichs. + * @return Die Beschreibung des Bereichs. + */ + public String getBeschreibung() { + return beschreibung; + } + + /** + * Definiert die benachbarten Bereiche des Bereichs. + * Jede Richtung führt entweder in einen anderen Bereich oder ist 'null' (kein Ausgang). + * @param nord Der im Norden benachbarte Bereich. + * @param ost Der im Osten benachbarte Bereich. + * @param sued Der im Süden benachbarte Bereich. + * @param west Der im Westen benachbarte Bereich. + */ + public void setNachbarn(Bereich nord, Bereich ost, Bereich sued, Bereich west) { + this.nord = nord; + this.ost = ost; + this.sued = sued; + this.west = west; + } + + /** + * Liefert den im Norden benachbarten Bereich. + * @return Den im Norden benachbarten Bereich. + */ + public Bereich getNord() { + return nord; + } + + /** + * Liefert den im Osten benachbarten Bereich. + * @return Den im Osten benachbarten Bereich. + */ + public Bereich getOst() { + return ost; + } + + /** + * Liefert den im Süden benachbarten Bereich. + * @return Den im Süden benachbarten Bereich. + */ + public Bereich getSued() { + return sued; + } + + /** + * Liefert den im Westen benachbarten Bereich. + * @return Den im Westen benachbarten Bereich. + */ + public Bereich getWest() { + return west; + } + +} diff --git a/src/nogard/schritt4/Program.java b/src/nogard/schritt4/Program.java new file mode 100644 index 0000000..d6f0e7f --- /dev/null +++ b/src/nogard/schritt4/Program.java @@ -0,0 +1,9 @@ +package nogard.schritt4; + +public class Program { + + public static void main(String[] args) { + new Spiel().spielen(); + } + +} diff --git a/src/nogard/schritt4/Spiel.java b/src/nogard/schritt4/Spiel.java new file mode 100644 index 0000000..f5138f1 --- /dev/null +++ b/src/nogard/schritt4/Spiel.java @@ -0,0 +1,144 @@ +package nogard.schritt4; + +import java.util.Scanner; + +/** + * Dies ist die Hauptklasse der Anwendung "Die Welt von Nogard". + * + * "Die Welt von Nogard" ist ein sehr einfaches, textbasiertes Adventure-Game, in dem sich ein Spieler durch Nogard bewegen kann. + * + * Das Spiel sollte auf jeden Fall ausgebaut werden, damit es interessanter wird! + * + * Zum Spielen muss an einer Instanz dieser Klasse die Methode "spielen()" aufgerufen werden. + * + * Diese Klasse erzeugt und initialisiert alle Objekte der Anwendung: + * - Sie legt alle Bereiche an. Anschließend startet das Spiel. + * - Sie wertet die Befehle aus und sorgt für ihre Ausführung. + */ +public class Spiel { + private Bereich aktiverBereich; + + /** + * Die Hauptmethode zum Spielen. + * Läuft bis zum Ende des Spiels in einer Schleife. + */ + public void spielen() { + erzeugeDorf(); + + ausgebenStartText(); + aktiverBereich.getInfo(); + + // 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(); + // Befehl interpretieren. + String[] befehl = input.trim().split(" "); + // Abbruch bei fehlender Eingabe. + if(befehl.length == 0) { + System.out.println("Ich weiß nicht, was Du meinst ..."); + end = false; + } + else { + // Auswerten des Befehls. + String befehlWort = befehl[0].trim(); + if (befehlWort.equalsIgnoreCase("go")) { + wechselBereich(befehl); + end = false; + } + else if (befehlWort.equalsIgnoreCase("help")) { + ausgebenHilfeText(); + end = false; + } + else if (befehlWort.equalsIgnoreCase("quit")) { + end = true; + } + else { + System.out.println("Ich weiß nicht, was Du meinst ..."); + end = false; + } + } + } + ausgebenEndText(); + + } + + private void wechselBereich(String[] befehl) { + if (befehl.length < 2) { + System.out.println("Wohin möchtest Du gehen?"); + } + else { + String richtung = befehl[1].trim(); + Bereich neuerBereich; + if(richtung.equalsIgnoreCase("north")) { + neuerBereich = aktiverBereich.getNord(); + } + else if(richtung.equalsIgnoreCase("east")) { + neuerBereich = aktiverBereich.getOst(); + } + else if(richtung.equalsIgnoreCase("south")) { + neuerBereich = aktiverBereich.getSued(); + } + else if(richtung.equalsIgnoreCase("west")) { + neuerBereich = aktiverBereich.getWest(); + } + else { + neuerBereich = null; + } + // Auswertung der gefundenen Bereichs. + if (neuerBereich == null) { + System.out.println("Dort geht es nicht weiter."); + } + else { + aktiverBereich = neuerBereich; + aktiverBereich.getInfo(); + } + } + } + + + private void ausgebenHilfeText() { + System.out.println("Du irrst in Nogard herum."); + System.out.println("Dir stehen folgende Befehle zur Verfügung:"); + System.out.println("\tgo"); + System.out.println("\tquit"); + System.out.println("\thelp"); + } + + private void 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"); + + // Die Nachbarschaften festlegen. + friedhof.setNachbarn(null, null, hexenhaus, null); + wald.setNachbarn(hexenhaus, taverne, null, null); + taverne.setNachbarn(rathaus, null, null, wald); + hexenhaus.setNachbarn(friedhof, rathaus, null, null); + rathaus.setNachbarn(null, null, taverne, hexenhaus); + + // Das Spielt startet im Wald. + aktiverBereich = wald; + } + + private void ausgebenEndText() { + // Endbildschirm ausgeben. + 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(); + } +} diff --git a/src/nogard/schritt5/Befehl.java b/src/nogard/schritt5/Befehl.java new file mode 100644 index 0000000..b7c0cf2 --- /dev/null +++ b/src/nogard/schritt5/Befehl.java @@ -0,0 +1,26 @@ +package nogard.schritt5; + +public class Befehl { + private final String befehl_wort; + private final String befehl_zusatz; + + public Befehl(String wort) { + befehl_wort = wort; + befehl_zusatz = null; + } + + public Befehl(String wort, String zusatz) { + befehl_wort = wort; + befehl_zusatz = zusatz; + } + + public String getWort() { + return befehl_wort; + } + + public String getZusatz() { + return befehl_zusatz; + } + + +} diff --git a/src/nogard/schritt5/BefehlFactory.java b/src/nogard/schritt5/BefehlFactory.java new file mode 100644 index 0000000..d4cb8a0 --- /dev/null +++ b/src/nogard/schritt5/BefehlFactory.java @@ -0,0 +1,38 @@ +package nogard.schritt5; + +import java.util.Arrays; + +public class BefehlFactory { + + public static Befehl createBefehl(String input) throws BefehlUnbekanntException { + Befehl b; + if (input.length() == 0) { + throw new BefehlUnbekanntException("Keine Argumente übergeben"); + } else { + String[] befehl_str = input.toLowerCase().split(" "); + String wort = befehl_str[0]; + b = switch (wort) { + case "go" -> createGoBefehl(befehl_str); + case "help", "quit" -> new Befehl(wort); + default -> throw new BefehlUnbekanntException(wort + " ist kein definierter Befehl."); + }; + } + return b; + } + + private static Befehl createGoBefehl(String[] befehl_str) throws BefehlUnbekanntException { + if (befehl_str.length != 2) { + throw new BefehlUnbekanntException("Befehl 'go' benötigt 2 parameter"); + } + + String befehl_wort = befehl_str[0]; + String befehl_zusatz = befehl_str[1]; + + for (Richtungen r: Richtungen.values()) { + if (r.name().equalsIgnoreCase(befehl_zusatz)) { + return new Befehl(befehl_wort, befehl_zusatz); + } + } + throw new BefehlUnbekanntException(befehl_zusatz + " ist keine valide Richtung."); + } +} diff --git a/src/nogard/schritt5/BefehlUnbekanntException.java b/src/nogard/schritt5/BefehlUnbekanntException.java new file mode 100644 index 0000000..f99ede4 --- /dev/null +++ b/src/nogard/schritt5/BefehlUnbekanntException.java @@ -0,0 +1,14 @@ +package nogard.schritt5; + +public class BefehlUnbekanntException extends Exception { + private String befehl; + + public BefehlUnbekanntException(String befehl) { + this.befehl = befehl; + } + + @Override + public String getMessage() { + return befehl; + } +} diff --git a/src/nogard/schritt5/Bereich.java b/src/nogard/schritt5/Bereich.java new file mode 100644 index 0000000..247e879 --- /dev/null +++ b/src/nogard/schritt5/Bereich.java @@ -0,0 +1,97 @@ +package nogard.schritt5; + +import java.util.HashMap; +import java.util.LinkedList; +import java.util.Map; + +/** + * Diese Klasse modelliert Bereiche.Ein Bereich kann ein Gebiet, ein Haus, ein Raum etc. sein. + * + * Jeder Bereich ist mit anderen Bereichen �ber Ausg�nge verbunden. M�gliche Ausg�nge liegen im Norden, Osten, S�den und Westen. + * + * F�r jeden Ausgang h�lt ein Bereich eine Referenz auf den benachbarten Bereich parat. + */ +public class Bereich { + + private final String beschreibung; + private final Map nachbarn; + private final LinkedList gegenstaende; + /** + * Konstruktor. + * @param beschreibung Die Beschreibung des Areals. + */ + public Bereich(String beschreibung) { + this.beschreibung = beschreibung; + nachbarn = new HashMap<>(); + gegenstaende = new LinkedList<>(); + + for (Richtungen r: Richtungen.values()) { + nachbarn.put(r, null); + } + } + + /** + * Liefert die Beschreibung des Bereichs. + * @return Die Beschreibung des Bereichs. + */ + public String getBeschreibung() { + return beschreibung; + } + + /** + * Setzt den Nachbarn des Bereiches. + * @param r Die Richtung / Ort des Nachbarbereichs. + * @param n Der Nachbar welcher Relativ zu diesem Objekt liegt. + */ + public void setNachbar(Richtungen r, Bereich n) { + nachbarn.put(r, n); + } + + /** + * + * @param richtung Die Richtung in welcher ein Nachbar liegen könnte. + * @return Den Nachbarn in der angegebenen Richtung, oder NULL wenn in der Richtung kein Bereich liegt. + */ + public Bereich getNachbar(Richtungen richtung) { + return nachbarn.get(richtung); + } + + public void platziereGegenstand(Gegenstand g) { + gegenstaende.add(g); + } + + public void entferneGegenstand(Gegenstand g) throws GegenstandNichtVorhandenException { + boolean success = gegenstaende.remove(g); + if (!success) { + throw new GegenstandNichtVorhandenException(g); + } + } + + public Gegenstand sucheGegenstand(String name) throws GegenstandNichtVorhandenException { + for (Gegenstand g: gegenstaende) { + if (g.getName().equalsIgnoreCase(name)) { + return g; + } + } + + throw new GegenstandNichtVorhandenException(name); + } + + public String getInfo() { + StringBuilder sb = new StringBuilder(); + sb.append("Du bist im Bereich "); + sb.append(getBeschreibung()); + sb.append("\nDeine Nachbarn sind:\n"); + for (Map.Entry paar: nachbarn.entrySet()) { + if (paar.getValue() != null) { + sb.append("\n\t").append(paar.getKey().name()); + } + } + sb.append("\nGegenstände:\n"); + for (Gegenstand g: gegenstaende) { + sb.append("\n\t").append(g.getInfo()); + } + + return sb.toString(); + } +} diff --git a/src/nogard/schritt5/Gegenstand.java b/src/nogard/schritt5/Gegenstand.java new file mode 100644 index 0000000..5559f03 --- /dev/null +++ b/src/nogard/schritt5/Gegenstand.java @@ -0,0 +1,32 @@ +package nogard.schritt5; + +public class Gegenstand { + private String name; + private String description; + private float weight_kg; + + public Gegenstand(String name, String description, float weight_kg) { + this.name = name; + this.description = description; + this.weight_kg = weight_kg; + } + + public String getName() { + return name; + } + + public String getDescription() { + return description; + } + + public float getWeight_kg() { + return weight_kg; + } + + public String getInfo() { + return "Name: " + name + + "\nBeschreibung: " + description + + "\nGewicht" + weight_kg + + "\n"; + } +} diff --git a/src/nogard/schritt5/GegenstandNichtVorhandenException.java b/src/nogard/schritt5/GegenstandNichtVorhandenException.java new file mode 100644 index 0000000..62b23ee --- /dev/null +++ b/src/nogard/schritt5/GegenstandNichtVorhandenException.java @@ -0,0 +1,20 @@ +package nogard.schritt5; + +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/schritt5/GegenstandZuSchwerException.java b/src/nogard/schritt5/GegenstandZuSchwerException.java new file mode 100644 index 0000000..11f830a --- /dev/null +++ b/src/nogard/schritt5/GegenstandZuSchwerException.java @@ -0,0 +1,9 @@ +package nogard.schritt5; + +public class GegenstandZuSchwerException extends Exception { + private final String text; + + public GegenstandZuSchwerException(Gegenstand g) { + text = "Ist zu schwer: " + g.getDescription(); + } +} diff --git a/src/nogard/schritt5/Nahrung.java b/src/nogard/schritt5/Nahrung.java new file mode 100644 index 0000000..56967a7 --- /dev/null +++ b/src/nogard/schritt5/Nahrung.java @@ -0,0 +1,19 @@ +package nogard.schritt5; + +public class Nahrung extends Gegenstand { + private final int nutrients; + + public Nahrung(String name, String description, float weight_kg, int nutrients) { + super(name, description, weight_kg); + this.nutrients = nutrients; + } + + public int getNutrients() { + return nutrients; + } + + public String getInfo() { + return super.getInfo() + + getNutrients(); + } +} diff --git a/src/nogard/schritt5/Program.java b/src/nogard/schritt5/Program.java new file mode 100644 index 0000000..afc254b --- /dev/null +++ b/src/nogard/schritt5/Program.java @@ -0,0 +1,9 @@ +package nogard.schritt5; + +public class Program { + + public static void main(String[] args) { + new Spiel().spielen(); + } + +} diff --git a/src/nogard/schritt5/Richtungen.java b/src/nogard/schritt5/Richtungen.java new file mode 100644 index 0000000..59343ab --- /dev/null +++ b/src/nogard/schritt5/Richtungen.java @@ -0,0 +1,5 @@ +package nogard.schritt5; + +public enum Richtungen { + NORTH, EAST, SOUTH, WEST, UP, DOWN +} diff --git a/src/nogard/schritt5/Spiel.java b/src/nogard/schritt5/Spiel.java new file mode 100644 index 0000000..f2d0d62 --- /dev/null +++ b/src/nogard/schritt5/Spiel.java @@ -0,0 +1,122 @@ +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! + * + * Zum Spielen muss an einer Instanz dieser Klasse die Methode "spielen()" aufgerufen werden. + * + * Diese Klasse erzeugt und initialisiert alle Objekte der Anwendung: + * - Sie legt alle Bereiche an. Anschlie�end startet das Spiel. + * - Sie wertet die Befehle aus und sorgt f�r ihre Ausf�hrung. + */ +public class Spiel { + private Bereich aktiverBereich; + + public Spiel() { + erzeugeDorf(); + } + /** + * Die Hauptmethode zum Spielen. + * L�uft bis zum Ende des Spiels in einer Schleife. + */ + public void spielen() { + ausgebenStartText(); + + // Befehle einlesen und auswerten. + Scanner scannerZeile = new Scanner(System.in); + + boolean end = false; + while (! end) { + // Eingabeaufforderung anzeigen. + System.out.print("> "); + String input = scannerZeile.nextLine(); + try { + Befehl befehl = BefehlFactory.createBefehl(input); + end = ausfuehrenBefehl(befehl); + } catch (BefehlUnbekanntException e) { + System.out.println(e.getMessage()); + } + } + + // Endbildschirm ausgeben. + ausgebenEndText(); + } + + private boolean ausfuehrenBefehl(Befehl befehl) { + boolean end = false; + switch (befehl.getWort()) { + case "go" -> wechselBereich(befehl); + case "help" -> ausgebenHilfeText(); + case "quit" -> end = true; + default -> ausgebenFehlerBefehl(); + } + return end; + } + + private void wechselBereich(Befehl befehl) { + Richtungen richtung = Richtungen.valueOf(befehl.getZusatz().toUpperCase()); + Bereich neuerBereich = aktiverBereich.getNachbar(richtung); + + if (neuerBereich == null) { + System.out.println("Hier geht es nicht weiter"); + } else { + aktiverBereich = neuerBereich; + } + System.out.println(aktiverBereich.getInfo()); + } + + private void ausgebenHilfeText() { + System.out.println("Du irrst in Nogard herum."); + System.out.println("Dir stehen folgende Befehle zur Verf�gung:"); + System.out.println("\tgo"); + System.out.println("\tquit"); + System.out.println("\thelp"); + } + + private void ausgebenEndText() { + System.out.println("Danke f�r dieses Spiel. Auf Wiedersehen."); + } + + private void ausgebenStartText() { + // Begr��ungsbildschirm ausgeben. + System.out.println("Willkommen in Nogard!"); + System.out.println("Entdecke die Welt von Nogard. Doch Vorsicht, �berall lauern Gefahren!"); + System.out.println("Wenn du Hilfe ben�tigst, tippe 'help'."); + System.out.println(); + System.out.println(aktiverBereich.getInfo()); + } + + private void erzeugeDorf() { + // Die Bereiche erzeugen. + Bereich friedhof = new Bereich("auf einem Friedhof, umgeben von dunklen Tannen"); + Bereich wald = new Bereich("im dunklen Stadtwald von Nogard"); + Bereich taverne = new Bereich("in der Taverne, mit zwielichtigen Gestalten an der Theke"); + Bereich hexenhaus = new Bereich("im finsteren Hexenhaus"); + Bereich rathaus = new Bereich("im Rathaus von Nogard"); + Bereich weinkeller = new Bereich("Weinkeller der Taverne"); + + // Die Nachbarschaften festlegen. + taverne.setNachbar(Richtungen.NORTH, rathaus); + taverne.setNachbar(Richtungen.WEST, wald); + taverne.setNachbar(Richtungen.DOWN, weinkeller); + weinkeller.setNachbar(Richtungen.UP, taverne); + wald.setNachbar(Richtungen.NORTH, friedhof); + friedhof.setNachbar(Richtungen.SOUTH, wald); + friedhof.setNachbar(Richtungen.EAST, hexenhaus); + hexenhaus.setNachbar(Richtungen.WEST, friedhof); + + // Das Spielt startet im Wald. + aktiverBereich = wald; + } + + private void ausgebenFehlerBefehl() { + System.out.println("Ich wei� nicht, was Du meinst ..."); + } + +} diff --git a/src/nogard/schritt5/Spieler.java b/src/nogard/schritt5/Spieler.java new file mode 100644 index 0000000..e84fd2c --- /dev/null +++ b/src/nogard/schritt5/Spieler.java @@ -0,0 +1,46 @@ +package nogard.schritt5; + +import java.util.LinkedList; + +public class Spieler { + private final String name; + private final float traglast; + private final int fitness; + private final LinkedList items; + private final Bereich bereich; + + public Spieler(String name, float traglast, int fitness, Bereich bereich) { + this.name = name; + this.traglast = traglast; + this.fitness = fitness; + items = new LinkedList<>(); + this.bereich = bereich; + } + + public float getTraglast() { + float total_weight_kg = 0; + for (Gegenstand g: items) { + total_weight_kg += g.getWeight_kg(); + } + return total_weight_kg; + } + + public void aufnehmenGegenstand(Gegenstand g) { + items.add(g); + } + + public String getInfo() { + StringBuilder sb = new StringBuilder(); + sb.append("Spieler:"); + sb.append("\n\tName: ").append(name); + sb.append("\n\tFitness: ").append(fitness); + sb.append("\n\tTraglast: ").append(traglast); + sb.append("\n\tItems: ["); + for (Gegenstand g: items) { + sb.append(g.getName()).append(", "); + } + sb.append("\n\tBereich: ").append(bereich.getBeschreibung()); + + return sb.toString(); + } +}