nogard oder so

.idea/encodings.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding">
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt0/Bereich.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt0/Spiel.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt1/Bereich.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt1/Spiel.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt2/Bereich.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt2/Spiel.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt2/schritt1/Bereich.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt2/schritt1/Spiel.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt3/Bereich.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt3/Bereich.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt3/Spiel.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt3/Spiel.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt3/schritt3/Bereich.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt3/schritt3/Spiel.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt4/Bereich.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt4/Bereich.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt4/Spiel.java" charset="windows-1252" />
+    <file url="file://$PROJECT_DIR$/src/nogard/schritt4/Spiel.java" charset="windows-1252" />
+  </component>
+</project>

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);
+    }
+}

src/interfaces/rechteck/IRechnen.java

@@ -0,0 +1,5 @@
+package interfaces.rechteck;
+
+public interface IRechnen {
+    double berechne(double zahl1, double zahl2);
+}

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

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);
+    }
+
+}

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);
+    }
+}

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 <20>ber Ausg<73>nge verbunden. M<>gliche Ausg<73>nge liegen im Norden, Osten, S<>den und Westen.
+ * 
+ * F<>r jeden Ausgang h<>lt ein Bereich eine Referenz auf den benachbarten Bereich parat.
+ */
+public class Bereich {
+
+	private 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;
+	}
+
+}

src/nogard/schritt0/Program.java

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

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<69>end startet das Spiel. 
+ *  - Sie wertet die Befehle aus und sorgt f<>r ihre Ausf<73>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<67><72>ungsbildschirm ausgeben.
+        System.out.println("Willkommen in Nogard!");
+        System.out.println("Entdecke die Welt von Nogard. Doch Vorsicht, <20>berall lauern Gefahren!");
+        System.out.println("Wenn du Hilfe ben<65>tigst, tippe 'help'.");
+        System.out.println();
+        System.out.println("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<EFBFBD>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<65> 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<EFBFBD>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<72>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<65> nicht, was Du meinst ...");
+	                end = false;
+	            }
+            }
+        }
+        
+        // Endbildschirm ausgeben.
+		System.out.println("Danke f<>r dieses Spiel. Auf Wiedersehen.");
+    }
+}

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 <20>ber Ausg<73>nge verbunden. M<>gliche Ausg<73>nge liegen im Norden, Osten, S<>den und Westen.
+ * 
+ * F<>r jeden Ausgang h<>lt ein Bereich eine Referenz auf den benachbarten Bereich parat.
+ */
+public class Bereich {
+
+	private 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;
+	}
+
+}

src/nogard/schritt1/Program.java

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

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<69>end startet das Spiel. 
+ *  - Sie wertet die Befehle aus und sorgt f<>r ihre Ausf<73>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<65> 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<65> 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<72>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<67><72>ungsbildschirm ausgeben.
+        System.out.println("Willkommen in Nogard!");
+        System.out.println("Entdecke die Welt von Nogard. Doch Vorsicht, <20>berall lauern Gefahren!");
+        System.out.println("Wenn du Hilfe ben<65>tigst, tippe 'help'.");
+        System.out.println();
+    }
+
+
+    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<EFBFBD>den.");
+		}
+		if(aktiverBereich.getWest() != null) {
+			System.out.println("\tWesten.");
+		}
+	}
+}

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

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]);
+    }
+}

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

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 <20>ber Ausg<73>nge verbunden. M<>gliche Ausg<73>nge liegen im Norden, Osten, S<>den und Westen.
+ * 
+ * F<>r jeden Ausgang h<>lt ein Bereich eine Referenz auf den benachbarten Bereich parat.
+ */
+public class Bereich {
+
+	private 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;
+	}
+
+}

src/nogard/schritt2/Program.java

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

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<69>end startet das Spiel. 
+ *  - Sie wertet die Befehle aus und sorgt f<>r ihre Ausf<73>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<65> 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<65> 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<72>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<67><72>ungsbildschirm ausgeben.
+        System.out.println("Willkommen in Nogard!");
+        System.out.println("Entdecke die Welt von Nogard. Doch Vorsicht, <20>berall lauern Gefahren!");
+        System.out.println("Wenn du Hilfe ben<65>tigst, tippe 'help'.");
+        System.out.println();
+    }
+
+
+    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<EFBFBD>den.");
+		}
+		if(aktiverBereich.getWest() != null) {
+			System.out.println("\tWesten.");
+		}
+	}
+}

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

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]);
+    }
+}

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

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 <20>ber Ausg<73>nge verbunden. M<>gliche Ausg<73>nge liegen im Norden, Osten, S<>den und Westen.
+ * 
+ * F<>r jeden Ausgang h<>lt ein Bereich eine Referenz auf den benachbarten Bereich parat.
+ */
+public class Bereich {
+
+	private 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<EFBFBD>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;
+	}
+
+}

src/nogard/schritt3/Program.java

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

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<69>end startet das Spiel. 
+ *  - Sie wertet die Befehle aus und sorgt f<>r ihre Ausf<73>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<65> 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<65> 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<72>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<67><72>ungsbildschirm ausgeben.
+        System.out.println("Willkommen in Nogard!");
+        System.out.println("Entdecke die Welt von Nogard. Doch Vorsicht, <20>berall lauern Gefahren!");
+        System.out.println("Wenn du Hilfe ben<65>tigst, tippe 'help'.");
+        System.out.println();
+    }
+}

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

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]);
+    }
+}

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

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 <20>ber Ausg<73>nge verbunden. M<>gliche Ausg<73>nge liegen im Norden, Osten, S<>den und Westen.
+ * 
+ * F<>r jeden Ausgang h<>lt ein Bereich eine Referenz auf den benachbarten Bereich parat.
+ */
+public class Bereich {
+
+	private 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<EFBFBD>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;
+	}
+
+}

src/nogard/schritt4/Program.java

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

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<69>end startet das Spiel. 
+ *  - Sie wertet die Befehle aus und sorgt f<>r ihre Ausf<73>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<65> 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<65> 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<72>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<67><72>ungsbildschirm ausgeben.
+        System.out.println("Willkommen in Nogard!");
+        System.out.println("Entdecke die Welt von Nogard. Doch Vorsicht, <20>berall lauern Gefahren!");
+        System.out.println("Wenn du Hilfe ben<65>tigst, tippe 'help'.");
+        System.out.println();
+    }
+}

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

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

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

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 <20>ber Ausg<73>nge verbunden. M<>gliche Ausg<73>nge liegen im Norden, Osten, S<>den und Westen.
+ * 
+ * F<>r jeden Ausgang h<>lt ein Bereich eine Referenz auf den benachbarten Bereich parat.
+ */
+public class Bereich {
+
+	private final String beschreibung;
+	private final Map<Richtungen, Bereich> nachbarn;
+	private final LinkedList<Gegenstand> gegenstaende;
+	/**
+     * Konstruktor.
+     * @param beschreibung	Die Beschreibung des Areals.
+     */
+    public Bereich(String beschreibung) {
+        this.beschreibung = beschreibung;
+        nachbarn = new HashMap<>();
+		gegenstaende = new LinkedList<>();
+
+		for (Richtungen r: Richtungen.values()) {
+			nachbarn.put(r, null);
+		}
+    }
+
+    /**
+     * Liefert die Beschreibung des Bereichs.
+     * @return	Die Beschreibung des Bereichs.
+     */
+    public String getBeschreibung() {
+        return beschreibung;
+    }
+
+	/**
+	 * Setzt den Nachbarn des Bereiches.
+	 * @param r Die Richtung / Ort des Nachbarbereichs.
+	 * @param n Der Nachbar welcher Relativ zu diesem Objekt liegt.
+	 */
+	public void setNachbar(Richtungen r, Bereich n) {
+		nachbarn.put(r, n);
+	}
+
+	/**
+	 *
+	 * @param richtung Die Richtung in welcher ein Nachbar liegen könnte.
+	 * @return Den Nachbarn in der angegebenen Richtung, oder NULL wenn in der Richtung kein Bereich liegt.
+	 */
+	public Bereich getNachbar(Richtungen richtung) {
+		return nachbarn.get(richtung);
+	}
+
+	public void platziereGegenstand(Gegenstand g) {
+		gegenstaende.add(g);
+	}
+
+	public void entferneGegenstand(Gegenstand g) throws GegenstandNichtVorhandenException {
+		boolean success = gegenstaende.remove(g);
+		if (!success) {
+			throw new GegenstandNichtVorhandenException(g);
+		}
+	}
+
+	public Gegenstand sucheGegenstand(String name) throws GegenstandNichtVorhandenException {
+		for (Gegenstand g: gegenstaende) {
+			if (g.getName().equalsIgnoreCase(name)) {
+				return g;
+			}
+		}
+
+		throw new GegenstandNichtVorhandenException(name);
+	}
+
+	public String getInfo() {
+		StringBuilder sb = new StringBuilder();
+		sb.append("Du bist im Bereich ");
+		sb.append(getBeschreibung());
+		sb.append("\nDeine Nachbarn sind:\n");
+		for (Map.Entry<Richtungen, Bereich> paar: nachbarn.entrySet()) {
+			if (paar.getValue() != null) {
+				sb.append("\n\t").append(paar.getKey().name());
+			}
+		}
+		sb.append("\nGegenstände:\n");
+		for (Gegenstand g: gegenstaende) {
+			sb.append("\n\t").append(g.getInfo());
+		}
+
+		return sb.toString();
+	}
+}

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

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

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

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

src/nogard/schritt5/Program.java

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

src/nogard/schritt5/Richtungen.java

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

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<69>end startet das Spiel. 
+ *  - Sie wertet die Befehle aus und sorgt f<>r ihre Ausf<73>hrung.
+ */
+public class Spiel {
+	private Bereich aktiverBereich;
+
+	public Spiel() {
+		erzeugeDorf();
+	}
+    /**
+     * Die Hauptmethode zum Spielen. 
+     * L<>uft bis zum Ende des Spiels in einer Schleife.
+     */
+    public void spielen() {
+		ausgebenStartText();
+
+		// Befehle einlesen und auswerten.
+        Scanner scannerZeile = new Scanner(System.in);
+
+		boolean end = false;
+        while (! end) {
+            // Eingabeaufforderung anzeigen.
+            System.out.print("> ");
+			String input = scannerZeile.nextLine();
+			try {
+				Befehl befehl = BefehlFactory.createBefehl(input);
+				end = ausfuehrenBefehl(befehl);
+			} catch (BefehlUnbekanntException e) {
+				System.out.println(e.getMessage());
+			}
+		}
+        
+        // Endbildschirm ausgeben.
+		ausgebenEndText();
+	}
+
+	private boolean ausfuehrenBefehl(Befehl befehl) {
+		boolean end = false;
+		switch (befehl.getWort()) {
+			case "go" -> wechselBereich(befehl);
+			case "help" -> ausgebenHilfeText();
+			case "quit" -> end = true;
+			default -> ausgebenFehlerBefehl();
+		}
+		return end;
+	}
+
+	private void wechselBereich(Befehl befehl) {
+		Richtungen richtung = Richtungen.valueOf(befehl.getZusatz().toUpperCase());
+		Bereich neuerBereich = aktiverBereich.getNachbar(richtung);
+
+		if (neuerBereich == null) {
+			System.out.println("Hier geht es nicht weiter");
+		} else {
+			aktiverBereich = neuerBereich;
+		}
+		System.out.println(aktiverBereich.getInfo());
+	}
+
+	private void ausgebenHilfeText() {
+		System.out.println("Du irrst in Nogard herum.");
+		System.out.println("Dir stehen folgende Befehle zur Verf<72>gung:");
+		System.out.println("\tgo");
+		System.out.println("\tquit");
+		System.out.println("\thelp");
+	}
+
+	private void ausgebenEndText() {
+		System.out.println("Danke f<>r dieses Spiel. Auf Wiedersehen.");
+	}
+
+	private void ausgebenStartText() {
+		// Begr<67><72>ungsbildschirm ausgeben.
+		System.out.println("Willkommen in Nogard!");
+		System.out.println("Entdecke die Welt von Nogard. Doch Vorsicht, <20>berall lauern Gefahren!");
+		System.out.println("Wenn du Hilfe ben<65>tigst, tippe 'help'.");
+		System.out.println();
+		System.out.println(aktiverBereich.getInfo());
+	}
+
+	private void erzeugeDorf() {
+		// Die Bereiche erzeugen.
+		Bereich friedhof = new Bereich("auf einem Friedhof, umgeben von dunklen Tannen");
+		Bereich wald = new Bereich("im dunklen Stadtwald von Nogard");
+		Bereich taverne = new Bereich("in der Taverne, mit zwielichtigen Gestalten an der Theke");
+		Bereich hexenhaus = new Bereich("im finsteren Hexenhaus");
+		Bereich rathaus = new Bereich("im Rathaus von Nogard");
+		Bereich weinkeller = new Bereich("Weinkeller der Taverne");
+
+		// Die Nachbarschaften festlegen.
+		taverne.setNachbar(Richtungen.NORTH, rathaus);
+		taverne.setNachbar(Richtungen.WEST, wald);
+		taverne.setNachbar(Richtungen.DOWN, weinkeller);
+		weinkeller.setNachbar(Richtungen.UP, taverne);
+		wald.setNachbar(Richtungen.NORTH, friedhof);
+		friedhof.setNachbar(Richtungen.SOUTH, wald);
+		friedhof.setNachbar(Richtungen.EAST, hexenhaus);
+		hexenhaus.setNachbar(Richtungen.WEST, friedhof);
+
+		// Das Spielt startet im Wald.
+		aktiverBereich = wald;
+	}
+
+	private void ausgebenFehlerBefehl() {
+		System.out.println("Ich wei<65> nicht, was Du meinst ...");
+	}
+
+}

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<Gegenstand> items;
+    private final Bereich bereich;
+
+    public Spieler(String name, float traglast, int fitness, Bereich bereich) {
+        this.name = name;
+        this.traglast = traglast;
+        this.fitness = fitness;
+        items = new LinkedList<>();
+        this.bereich = bereich;
+    }
+
+    public float getTraglast() {
+        float total_weight_kg = 0;
+        for (Gegenstand g: items) {
+            total_weight_kg += g.getWeight_kg();
+        }
+        return total_weight_kg;
+    }
+
+    public void aufnehmenGegenstand(Gegenstand g) {
+        items.add(g);
+    }
+
+    public String getInfo() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Spieler:");
+        sb.append("\n\tName: ").append(name);
+        sb.append("\n\tFitness: ").append(fitness);
+        sb.append("\n\tTraglast: ").append(traglast);
+        sb.append("\n\tItems: [");
+        for (Gegenstand g: items) {
+            sb.append(g.getName()).append(", ");
+        }
+        sb.append("\n\tBereich: ").append(bereich.getBeschreibung());
+
+        return sb.toString();
+    }
+}