private Raum nordausgang;
private Raum suedausgang;
private Raum ostausgang;
private Raum westausgang;
import java.util.Set;
import java.util.HashMap;
/**
* Diese Klasse modelliert Räume in der Welt von Zuul.
*
* Ein "Raum" repräsentiert einen Ort in der virtuellen Landschaft des
* Spiels. Ein Raum ist mit anderen Räumen über Ausgänge verbunden.
* Für jeden existierenden Ausgang hält ein Raum eine Referenz auf
* den benachbarten Raum.
*
* @author Michael Kölling und David J. Barnes
* @version 31.07.2011
*/
class Raum
{
private String beschreibung;
private HashMap<String, Raum> ausgaenge; // die Ausgänge dieses Raums
/**
* Erzeuge einen Raum mit einer Beschreibung. Ein Raum
* hat anfangs keine Ausgänge.
* @param beschreibung enthält eine Beschreibung in der Form
* "in einer Küche" oder "auf einem Sportplatz".
*/
public Raum(String beschreibung)
{
this.beschreibung = beschreibung;
ausgaenge = new HashMap<String, Raum>();
}
public String gibBeschreibung()
{
return beschreibung;
}
/**
* Definiere einen Ausgang für diesen Raum.
* @param richtung die Richtung, in der der Ausgang liegen soll
* @param nachbar der Raum, der über diesen Ausgang erreicht wird
*/
public void setzeAusgang(String richtung, Raum nachbar)
{
ausgaenge.put(richtung, nachbar);
}
/**
* @return die kurze Beschreibung dieses Raums (die dem Konstruktor
* übergeben wurde).
*/
public String gibKurzbeschreibung()
{
return beschreibung;
}
/**
* Liefere eine lange Beschreibung dieses Raums, in der Form:
* Sie sind in der Küche.
* Ausgänge: nord west
* @return eine lange Beschreibung dieses Raumes.
*/
public String gibLangeBeschreibung()
{
return "Sie sind " + beschreibung + ".\n" + gibAusgaengeAlsString();
}
public String gibAusgaengeAlsString2()
{
String ergebnis = "Ausgänge: ";
if (aktuellerRaum.gibAusgang("north") != null) {
ergebnis += "north";
if (aktuellerRaum.gibAusgang("east") != null) {
ergebnis += "east";
if (aktuellerRaum.gibAusgang("south") != null) {
ergebnis += "south";
if (aktuellerRaum.gibAusgang("west") != null) {
ergebnis += "west";
}
}
}
return ergebnis;
}
}
/**
* Liefere eine Beschreibung der Ausgänge dieses Raumes,
* beispielsweise
* "Ausgänge: north west".
* @return eine Beschreibung der Ausgänge dieses Raumes.
*/
private String gibAusgaengeAlsString()
{
String ergebnis = "Ausgänge:";
Set<String> keys = ausgaenge.keySet();
for(String ausgang : keys)
ergebnis += " " + ausgang;
return ergebnis;
}
public Raum gibAusgang(String richtung)
{
return ausgaenge.get(richtung);
}
/**
* Liefere den Raum, den wir erreichen, wenn wir aus diesem Raum
* in die angegebene Richtung gehen. Liefere 'null', wenn in
* dieser Richtung kein Ausgang ist.
* @param richtung die Richtung, in die gegangen werden soll.
* @return den Raum in der angegebenen Richtung.
*/
}
/**
* Dies ist die Hauptklasse der Anwendung "Die Welt von Zuul".
* "Die Welt von Zuul" ist ein sehr einfaches, textbasiertes
* Adventure-Game. Ein Spieler kann sich in einer Umgebung bewegen,
* mehr nicht. Das Spiel sollte auf jeden Fall ausgebaut werden,
* damit es interessanter wird!
*
* Zum Spielen muss eine Instanz dieser Klasse erzeugt werden und
* an ihr die Methode "spielen" aufgerufen werden.
*
* Diese Instanz dieser Klasse erzeugt und initialisiert alle
* anderen Objekte der Anwendung: Sie legt alle Räume und einen
* Parser an und startet das Spiel. Sie wertet auch die Befehle
* aus, die der Parser liefert und sorgt für ihre Ausführung.
*
* @author Michael Kölling und David J. Barnes
* @version 31.07.2011
*/
class Spiel
{
private Parser parser;
private Raum aktuellerRaum;
/**
* Erzeuge ein Spiel und initialisiere die interne Raumkarte.
*/
public Spiel()
{
raeumeAnlegen();
parser = new Parser();
}
/**
* Erzeuge alle Räume und verbinde ihre Ausgänge miteinander.
*/
private void raeumeAnlegen()
{
Raum draussen, hoersaal, cafeteria, labor, buero;
// die Räume erzeugen
draussen = new Raum("vor dem Haupteingang der Universität");
hoersaal = new Raum("in einem Vorlesungssaal");
cafeteria = new Raum("in der Cafeteria der Uni");
labor = new Raum("in einem Rechnerraum");
buero = new Raum("im Verwaltungsbüro der Informatik");
// die Ausgänge initialisieren
draussen.setzeAusgang("east", hoersaal);
draussen.setzeAusgang("south", labor);
draussen.setzeAusgang("west", cafeteria);
hoersaal.setzeAusgang("west", draussen);
cafeteria.setzeAusgang("east", draussen);
labor.setzeAusgang("north", draussen);
labor.setzeAusgang("east", buero);
buero.setzeAusgang("west", labor);
aktuellerRaum = draussen; // das Spiel startet draussen
}
/**
* Die Hauptmethode zum Spielen. Läuft bis zum Ende des Spiels
* in einer Schleife.
*/
public void spielen()
{
willkommenstextAusgeben();
// Die Hauptschleife. Hier lesen wir wiederholt Befehle ein
// und führen sie aus, bis das Spiel beendet wird.
boolean beendet = false;
while (! beendet) {
Befehl befehl = parser.liefereBefehl();
beendet = verarbeiteBefehl(befehl);
}
System.out.println("Danke für dieses Spiel. Auf Wiedersehen.");
}
private void rauminfoAusgeben()
{
System.out.println("Sie sind " + aktuellerRaum.gibBeschreibung());
System.out.print("Ausgänge: ");
if (aktuellerRaum.gibAusgang("north") != null) {
System.out.print("north ");
}
if(aktuellerRaum.gibAusgang("east") != null) {
System.out.print("east ");
}
if(aktuellerRaum.gibAusgang("south") != null) {
System.out.print("south ");
}
if(aktuellerRaum.gibAusgang("west") != null) {
System.out.print("west ");
}
System.out.println();
}
/**
* Einen Begrüßungstext für den Spieler ausgeben.
*/
private void willkommenstextAusgeben()
{
System.out.println();
System.out.println("Willkommen zu Zuul!");
System.out.println("Zuul ist ein neues, unglaublich langweiliges Spiel.");
System.out.println("Tippen sie 'help', wenn Sie Hilfe brauchen.");
System.out.println();
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
/**
* Verarbeite einen gegebenen Befehl (führe ihn aus).
* @param befehl Der zu verarbeitende Befehl.
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean verarbeiteBefehl(Befehl befehl)
{
boolean moechteBeenden = false;
if(befehl.istUnbekannt()) {
System.out.println("Ich weiss nicht, was Sie meinen...");
return false;
}
String befehlswort = befehl.gibBefehlswort();
if (befehlswort.equals("help")) {
hilfstextAusgeben();
}
else if (befehlswort.equals("go")) {
wechsleRaum(befehl);
}
else if (befehlswort.equals("quit")) {
moechteBeenden = beenden(befehl);
}
// ansonsten: Befehl nicht erkannt.
return moechteBeenden;
}
// Implementierung der Benutzerbefehle:
/**
* Gib Hilfsinformationen aus.
* Hier geben wir eine etwas alberne und unklare Beschreibung
* aus, sowie eine Liste der Befehlswörter.
*/
private void hilfstextAusgeben()
{
System.out.println("Sie haben sich verlaufen. Sie sind allein.");
System.out.println("Sie irren auf dem Unigelände herum.");
System.out.println();
System.out.println("Ihnen stehen folgende Befehle zur Verfügung:");
parser.zeigeBefehle();
}
/**
* Versuche, in eine Richtung zu gehen. Wenn es einen Ausgang gibt,
* wechsele in den neuen Raum, ansonsten gib eine Fehlermeldung
* aus.
*/
private void wechsleRaum(Befehl befehl)
{
if(!befehl.hatZweitesWort()) {
// Gibt es kein zweites Wort, wissen wir nicht, wohin...
System.out.println("Wohin möchten Sie gehen?");
return;
}
String richtung = befehl.gibZweitesWort();
// Wir versuchen, den Raum zu verlassen.
Raum naechsterRaum = aktuellerRaum.gibAusgang(richtung);
if (naechsterRaum == null) {
System.out.println("Dort ist keine Tür!");
}
else {
aktuellerRaum = naechsterRaum;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
}
/**
* "quit" wurde eingegeben. Überprüfe den Rest des Befehls,
* ob das Spiel wirklich beendet werden soll.
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean beenden(Befehl befehl)
{
if(befehl.hatZweitesWort()) {
System.out.println("Was soll beendet werden?");
return false;
}
else {
return true; // Das Spiel soll beendet werden.
}
}
}
Wieviel davon verstanden und verinnerlicht?Es ist Kapitel 6. Ich habe bisher natürlich alles gelesen!
Du sollst alles bis jetzt verstanden haben, sonst macht das Weitermachen keinen Sinn! Schön langsam kann ich das nicht mehr mit Humor nehmen.Schwer zu sagen^^
Wenn du dabei alles verstanden hast, müsstest du die Aufgabe leicht lösen können.Es ist Kapitel 6. Ich habe bisher natürlich alles gelesen!
OK, welche der Projekte hast du bisher bearbeitet? Ich glaube im 2. oder 3. Kapitel ist ganz genau beschrieben, was du machen sollst.Es ist Kapitel 6. Ich habe bisher natürlich alles gelesen!
/**
* Beschreiben Sie hier die Klasse Gegenstand.
*
* @author (Ihr Name)
* @version (eine Versionsnummer oder ein Datum)
*/
public class Gegenstand
{
// Instanzvariablen - ersetzen Sie das folgende Beispiel mit Ihren Variablen
private int x;
private String gegenstandBeschreibung;
private int gegenstandGewicht;
/**
* Konstruktor für Objekte der Klasse Gegenstand
*/
public Gegenstand(String beschreibung, int gewicht)
{
this.gegenstandBeschreibung = beschreibung; // Instanzvariable initialisieren
this.gegenstandGewicht = gewicht;
x = 0;
}
/**
* Ein Beispiel einer Methode - ersetzen Sie diesen Kommentar mit Ihrem eigenen
*
* @param y ein Beispielparameter für eine Methode
* @return die Summe aus x und y
*/
public int beispielMethode(int y)
{
// tragen Sie hier den Code ein
return x + y;
}
}
/**
* Dies ist die Hauptklasse der Anwendung "Die Welt von Zuul".
* "Die Welt von Zuul" ist ein sehr einfaches, textbasiertes
* Adventure-Game. Ein Spieler kann sich in einer Umgebung bewegen,
* mehr nicht. Das Spiel sollte auf jeden Fall ausgebaut werden,
* damit es interessanter wird!
*
* Zum Spielen muss eine Instanz dieser Klasse erzeugt werden und
* an ihr die Methode "spielen" aufgerufen werden.
*
* Diese Instanz dieser Klasse erzeugt und initialisiert alle
* anderen Objekte der Anwendung: Sie legt alle Räume und einen
* Parser an und startet das Spiel. Sie wertet auch die Befehle
* aus, die der Parser liefert und sorgt für ihre Ausführung.
*
* @author Michael Kölling und David J. Barnes
* @version 31.07.2011
*/
class Spiel
{
private Parser parser;
private Raum aktuellerRaum;
private Gegenstand aktuellerGegenstand;
/**
* Erzeuge ein Spiel und initialisiere die interne Raumkarte.
*/
public Spiel()
{
raeumeAnlegen();
parser = new Parser();
aktuellerGegenstand = new Gegenstand("Buch", 50);
}
/**
* Erzeuge alle Räume und verbinde ihre Ausgänge miteinander.
*/
private void raeumeAnlegen()
{
Raum draussen, hoersaal, cafeteria, labor, buero, keller;
// die Räume erzeugen
draussen = new Raum("vor dem Haupteingang der Universität");
hoersaal = new Raum("in einem Vorlesungssaal");
cafeteria = new Raum("in der Cafeteria der Uni");
labor = new Raum("in einem Rechnerraum");
buero = new Raum("im Verwaltungsbüro der Informatik");
keller = new Raum("im Keller");
// die Ausgänge initialisieren
draussen.setzeAusgang("east", hoersaal);
draussen.setzeAusgang("south", labor);
draussen.setzeAusgang("west", cafeteria);
hoersaal.setzeAusgang("west", draussen);
cafeteria.setzeAusgang("east", draussen);
labor.setzeAusgang("north", draussen);
labor.setzeAusgang("east", buero);
buero.setzeAusgang("west", labor);
buero.setzeAusgang("down", keller);
keller.setzeAusgang("up", buero);
//Gegenstände erzeugen
keller = new Gegenstand("Buch", 50);
buero = new Gegenstand("Computer", 1500);
aktuellerRaum = draussen; // das Spiel startet draussen
}
/**
* Die Hauptmethode zum Spielen. Läuft bis zum Ende des Spiels
* in einer Schleife.
*/
public void spielen()
{
willkommenstextAusgeben();
// Die Hauptschleife. Hier lesen wir wiederholt Befehle ein
// und führen sie aus, bis das Spiel beendet wird.
boolean beendet = false;
while (! beendet) {
Befehl befehl = parser.liefereBefehl();
beendet = verarbeiteBefehl(befehl);
}
System.out.println("Danke für dieses Spiel. Auf Wiedersehen.");
}
private void umsehen()
{
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
private void essen()
{
System.out.println(aktuellerRaum.gibEssensBeschreibung());
}
private void rauminfoAusgeben()
{
System.out.println("Sie sind " + aktuellerRaum.gibBeschreibung());
System.out.print("Ausgänge: ");
if (aktuellerRaum.gibAusgang("north") != null) {
System.out.print("north ");
}
if(aktuellerRaum.gibAusgang("east") != null) {
System.out.print("east ");
}
if(aktuellerRaum.gibAusgang("south") != null) {
System.out.print("south ");
}
if(aktuellerRaum.gibAusgang("west") != null) {
System.out.print("west ");
}
System.out.println();
}
/**
* Einen Begrüßungstext für den Spieler ausgeben.
*/
private void willkommenstextAusgeben()
{
System.out.println();
System.out.println("Willkommen zu Zuul!");
System.out.println("Zuul ist ein neues, unglaublich langweiliges Spiel.");
System.out.println("Tippen sie 'help', wenn Sie Hilfe brauchen.");
System.out.println();
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
/**
* Verarbeite einen gegebenen Befehl (führe ihn aus).
* @param befehl Der zu verarbeitende Befehl.
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean verarbeiteBefehl(Befehl befehl)
{
boolean moechteBeenden = false;
if(befehl.istUnbekannt()) {
System.out.println("Ich weiss nicht, was Sie meinen...");
return false;
}
String befehlswort = befehl.gibBefehlswort();
if (befehlswort.equals("help")) {
hilfstextAusgeben();
}
else if (befehlswort.equals("go")) {
wechsleRaum(befehl);
}
else if (befehlswort.equals("look")) {
umsehen();
}
else if (befehlswort.equals("eat")) {
essen();
}
else if (befehlswort.equals("quit")) {
moechteBeenden = beenden(befehl);
}
// ansonsten: Befehl nicht erkannt.
return moechteBeenden;
}
// Implementierung der Benutzerbefehle:
/**
* Gib Hilfsinformationen aus.
* Hier geben wir eine etwas alberne und unklare Beschreibung
* aus, sowie eine Liste der Befehlswörter.
*/
private void hilfstextAusgeben()
{
System.out.println("Sie haben sich verlaufen. Sie sind allein.");
System.out.println("Sie irren auf dem Unigelände herum.");
System.out.println();
System.out.println("Ihnen stehen folgende Befehle zur Verfügung:");
parser.zeigeBefehle();
}
/**
* Versuche, in eine Richtung zu gehen. Wenn es einen Ausgang gibt,
* wechsele in den neuen Raum, ansonsten gib eine Fehlermeldung
* aus.
*/
private void wechsleRaum(Befehl befehl)
{
if(!befehl.hatZweitesWort()) {
// Gibt es kein zweites Wort, wissen wir nicht, wohin...
System.out.println("Wohin möchten Sie gehen?");
return;
}
String richtung = befehl.gibZweitesWort();
// Wir versuchen, den Raum zu verlassen.
Raum naechsterRaum = aktuellerRaum.gibAusgang(richtung);
if (naechsterRaum == null) {
System.out.println("Dort ist keine Tür!");
}
else {
aktuellerRaum = naechsterRaum;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
}
/**
* "quit" wurde eingegeben. Überprüfe den Rest des Befehls,
* ob das Spiel wirklich beendet werden soll.
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean beenden(Befehl befehl)
{
if(befehl.hatZweitesWort()) {
System.out.println("Was soll beendet werden?");
return false;
}
else {
return true; // Das Spiel soll beendet werden.
}
}
}
Wird das wirklich an irgendeiner Uni in richtigen Informatikstudiengängen gemacht? Uni-Aufgaben sinds hier ja nicht...Das wirklich Verstörende an dem Ganzen hier ist eigentlich, dass Unis/Hochschulen etc. anscheinend immer noch BlueJ als "das Java-Lernwerkzeug" schlechthin verkaufen.
Zu BlueJ gibt es nur eins zu sagen: Es su**t.
Dann musst du die Klasse Raum so erweitern dass sie Gegenstände aufnehmen kann.
Sie braucht dann eine ArrayList<Gegenstand>, eine Methode add(Gegenstand ...) und vermutlich auch eeine Möglichkeit die Gegenstände auszugeben ... je nach Aufgabenstellung
import java.util.Set;
import java.util.HashMap;
import java.util.ArrayList;
/**
* Diese Klasse modelliert Räume in der Welt von Zuul.
*
* Ein "Raum" repräsentiert einen Ort in der virtuellen Landschaft des
* Spiels. Ein Raum ist mit anderen Räumen über Ausgänge verbunden.
* Für jeden existierenden Ausgang hält ein Raum eine Referenz auf
* den benachbarten Raum.
*
* @author Michael Kölling und David J. Barnes
* @version 31.07.2011
*/
class Raum
{
private String beschreibung;
private HashMap<String, Raum> ausgaenge; // die Ausgänge dieses Raums
private Raum aktuellerRaum;
private ArrayList<Gegenstand> gegenstaende;
/**
* Erzeuge einen Raum mit einer Beschreibung. Ein Raum
* hat anfangs keine Ausgänge.
* @param beschreibung enthält eine Beschreibung in der Form
* "in einer Küche" oder "auf einem Sportplatz".
*/
public Raum(String beschreibung)
{
this.beschreibung = beschreibung;
ausgaenge = new HashMap<String, Raum>();
gegenstaende = new ArrayList<Gegenstand>();
gegenstaende.add(new Gegenstand("Buch", 150));
gegenstaende.add(new Gegenstand("Computer", 1500));
}
public String gibBeschreibung()
{
return beschreibung;
}
/**
* Definiere einen Ausgang für diesen Raum.
* @param richtung die Richtung, in der der Ausgang liegen soll
* @param nachbar der Raum, der über diesen Ausgang erreicht wird
*/
public void setzeAusgang(String richtung, Raum nachbar)
{
ausgaenge.put(richtung, nachbar);
}
/**
* @return die kurze Beschreibung dieses Raums (die dem Konstruktor
* übergeben wurde).
*/
public String gibKurzbeschreibung()
{
return beschreibung;
}
/**
* Liefere eine lange Beschreibung dieses Raums, in der Form:
* Sie sind in der Küche.
* Ausgänge: nord west
* @return eine lange Beschreibung dieses Raumes.
*/
public String gibLangeBeschreibung()
{
return "Sie sind " + beschreibung + ".\n" + gibAusgaengeAlsString();
}
public String gibEssensBeschreibung()
{
return "Sie haben nun gegessen und sind nicht mehr hungrig!";
}
public String gibAusgaengeAlsString2()
{
String ergebnis = "Ausgänge: ";
if (aktuellerRaum.gibAusgang("north") != null) {
ergebnis += "north";
if (aktuellerRaum.gibAusgang("east") != null) {
ergebnis += "east";
if (aktuellerRaum.gibAusgang("south") != null) {
ergebnis += "south";
if (aktuellerRaum.gibAusgang("west") != null) {
ergebnis += "west";
}
}
}
}
return ergebnis;
}
/**
* Liefere eine Beschreibung der Ausgänge dieses Raumes,
* beispielsweise
* "Ausgänge: north west".
* @return eine Beschreibung der Ausgänge dieses Raumes.
*/
private String gibAusgaengeAlsString()
{
String ergebnis = "Ausgänge:";
Set<String> keys = ausgaenge.keySet();
for(String ausgang : keys)
ergebnis += " " + ausgang;
return ergebnis;
}
public Raum gibAusgang(String richtung)
{
return ausgaenge.get(richtung);
}
/**
* Liefere den Raum, den wir erreichen, wenn wir aus diesem Raum
* in die angegebene Richtung gehen. Liefere 'null', wenn in
* dieser Richtung kein Ausgang ist.
* @param richtung die Richtung, in die gegangen werden soll.
* @return den Raum in der angegebenen Richtung.
*/
}
import java.util.Set;
import java.util.HashMap;
import java.util.ArrayList;
/**
* Diese Klasse modelliert Räume in der Welt von Zuul.
*
* Ein "Raum" repräsentiert einen Ort in der virtuellen Landschaft des
* Spiels. Ein Raum ist mit anderen Räumen über Ausgänge verbunden.
* Für jeden existierenden Ausgang hält ein Raum eine Referenz auf
* den benachbarten Raum.
*
* @author Michael Kölling und David J. Barnes
* @version 31.07.2011
*/
class Raum
{
private String beschreibung;
private HashMap<String, Raum> ausgaenge; // die Ausgänge dieses Raums
private Raum aktuellerRaum;
private ArrayList<Gegenstand> gegenstaende;
/**
* Erzeuge einen Raum mit einer Beschreibung. Ein Raum
* hat anfangs keine Ausgänge.
* @param beschreibung enthält eine Beschreibung in der Form
* "in einer Küche" oder "auf einem Sportplatz".
*/
public Raum(String beschreibung)
{
this.beschreibung = beschreibung;
ausgaenge = new HashMap<String, Raum>();
gegenstaende = new ArrayList<Gegenstand>();
}
public String gibBeschreibung()
{
return beschreibung;
}
public void addGegenstand(Gegenstand gegenstand)
{
gegenstaende.add(new Gegenstand("Buch", 150));
gegenstaende.add(new Gegenstand("Computer", 1500));
}
/**
* Definiere einen Ausgang für diesen Raum.
* @param richtung die Richtung, in der der Ausgang liegen soll
* @param nachbar der Raum, der über diesen Ausgang erreicht wird
*/
public void setzeAusgang(String richtung, Raum nachbar)
{
ausgaenge.put(richtung, nachbar);
}
/**
* @return die kurze Beschreibung dieses Raums (die dem Konstruktor
* übergeben wurde).
*/
public String gibKurzbeschreibung()
{
return beschreibung;
}
/**
* Liefere eine lange Beschreibung dieses Raums, in der Form:
* Sie sind in der Küche.
* Ausgänge: nord west
* @return eine lange Beschreibung dieses Raumes.
*/
public String gibLangeBeschreibung()
{
return "Sie sind " + beschreibung + ".\n" + gibAusgaengeAlsString();
}
public String gibEssensBeschreibung()
{
return "Sie haben nun gegessen und sind nicht mehr hungrig!";
}
public String gibAusgaengeAlsString2()
{
String ergebnis = "Ausgänge: ";
if (aktuellerRaum.gibAusgang("north") != null) {
ergebnis += "north";
if (aktuellerRaum.gibAusgang("east") != null) {
ergebnis += "east";
if (aktuellerRaum.gibAusgang("south") != null) {
ergebnis += "south";
if (aktuellerRaum.gibAusgang("west") != null) {
ergebnis += "west";
}
}
}
}
return ergebnis;
}
/**
* Liefere eine Beschreibung der Ausgänge dieses Raumes,
* beispielsweise
* "Ausgänge: north west".
* @return eine Beschreibung der Ausgänge dieses Raumes.
*/
private String gibAusgaengeAlsString()
{
String ergebnis = "Ausgänge:";
Set<String> keys = ausgaenge.keySet();
for(String ausgang : keys)
ergebnis += " " + ausgang;
return ergebnis;
}
public Raum gibAusgang(String richtung)
{
return ausgaenge.get(richtung);
}
/**
* Liefere den Raum, den wir erreichen, wenn wir aus diesem Raum
* in die angegebene Richtung gehen. Liefere 'null', wenn in
* dieser Richtung kein Ausgang ist.
* @param richtung die Richtung, in die gegangen werden soll.
* @return den Raum in der angegebenen Richtung.
*/
}
/**
* Dies ist die Hauptklasse der Anwendung "Die Welt von Zuul".
* "Die Welt von Zuul" ist ein sehr einfaches, textbasiertes
* Adventure-Game. Ein Spieler kann sich in einer Umgebung bewegen,
* mehr nicht. Das Spiel sollte auf jeden Fall ausgebaut werden,
* damit es interessanter wird!
*
* Zum Spielen muss eine Instanz dieser Klasse erzeugt werden und
* an ihr die Methode "spielen" aufgerufen werden.
*
* Diese Instanz dieser Klasse erzeugt und initialisiert alle
* anderen Objekte der Anwendung: Sie legt alle Räume und einen
* Parser an und startet das Spiel. Sie wertet auch die Befehle
* aus, die der Parser liefert und sorgt für ihre Ausführung.
*
* @author Michael Kölling und David J. Barnes
* @version 31.07.2011
*/
import java.util.ArrayList;
class Spiel
{
private Parser parser;
private Raum aktuellerRaum;
private Gegenstand aktuellerGegenstand;
private ArrayList<Gegenstand> gegenstaende;
/**
* Erzeuge ein Spiel und initialisiere die interne Raumkarte.
*/
public Spiel()
{
raeumeAnlegen();
parser = new Parser();
}
/**
* Erzeuge alle Räume und verbinde ihre Ausgänge miteinander.
*/
private void raeumeAnlegen()
{
Raum draussen, hoersaal, cafeteria, labor, buero, keller;
// die Räume erzeugen
draussen = new Raum("vor dem Haupteingang der Universität");
hoersaal = new Raum("in einem Vorlesungssaal");
cafeteria = new Raum("in der Cafeteria der Uni");
labor = new Raum("in einem Rechnerraum");
buero = new Raum("im Verwaltungsbüro der Informatik");
keller = new Raum("im Keller");
// die Ausgänge initialisieren
draussen.setzeAusgang("east", hoersaal);
draussen.setzeAusgang("south", labor);
draussen.setzeAusgang("west", cafeteria);
hoersaal.setzeAusgang("west", draussen);
cafeteria.setzeAusgang("east", draussen);
labor.setzeAusgang("north", draussen);
labor.setzeAusgang("east", buero);
buero.setzeAusgang("west", labor);
buero.setzeAusgang("down", keller);
keller.setzeAusgang("up", buero);
//Gegenstände erzeugen
keller = gegenstaende.addGegenstand( Gegenstand("Buch", 150));
buero = gegenstaende.addGegenstand(new Gegenstand("Computer", 1500));
aktuellerRaum = draussen; // das Spiel startet draussen
}
/**
* Die Hauptmethode zum Spielen. Läuft bis zum Ende des Spiels
* in einer Schleife.
*/
public void spielen()
{
willkommenstextAusgeben();
// Die Hauptschleife. Hier lesen wir wiederholt Befehle ein
// und führen sie aus, bis das Spiel beendet wird.
boolean beendet = false;
while (! beendet) {
Befehl befehl = parser.liefereBefehl();
beendet = verarbeiteBefehl(befehl);
}
System.out.println("Danke für dieses Spiel. Auf Wiedersehen.");
}
private void umsehen()
{
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
private void essen()
{
System.out.println(aktuellerRaum.gibEssensBeschreibung());
}
private void rauminfoAusgeben()
{
System.out.println("Sie sind " + aktuellerRaum.gibBeschreibung());
System.out.print("Ausgänge: ");
if (aktuellerRaum.gibAusgang("north") != null) {
System.out.print("north ");
}
if(aktuellerRaum.gibAusgang("east") != null) {
System.out.print("east ");
}
if(aktuellerRaum.gibAusgang("south") != null) {
System.out.print("south ");
}
if(aktuellerRaum.gibAusgang("west") != null) {
System.out.print("west ");
}
System.out.println();
}
/**
* Einen Begrüßungstext für den Spieler ausgeben.
*/
private void willkommenstextAusgeben()
{
System.out.println();
System.out.println("Willkommen zu Zuul!");
System.out.println("Zuul ist ein neues, unglaublich langweiliges Spiel.");
System.out.println("Tippen sie 'help', wenn Sie Hilfe brauchen.");
System.out.println();
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
/**
* Verarbeite einen gegebenen Befehl (führe ihn aus).
* @param befehl Der zu verarbeitende Befehl.
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean verarbeiteBefehl(Befehl befehl)
{
boolean moechteBeenden = false;
if(befehl.istUnbekannt()) {
System.out.println("Ich weiss nicht, was Sie meinen...");
return false;
}
String befehlswort = befehl.gibBefehlswort();
if (befehlswort.equals("help")) {
hilfstextAusgeben();
}
else if (befehlswort.equals("go")) {
wechsleRaum(befehl);
}
else if (befehlswort.equals("look")) {
umsehen();
}
else if (befehlswort.equals("eat")) {
essen();
}
else if (befehlswort.equals("quit")) {
moechteBeenden = beenden(befehl);
}
// ansonsten: Befehl nicht erkannt.
return moechteBeenden;
}
// Implementierung der Benutzerbefehle:
/**
* Gib Hilfsinformationen aus.
* Hier geben wir eine etwas alberne und unklare Beschreibung
* aus, sowie eine Liste der Befehlswörter.
*/
private void hilfstextAusgeben()
{
System.out.println("Sie haben sich verlaufen. Sie sind allein.");
System.out.println("Sie irren auf dem Unigelände herum.");
System.out.println();
System.out.println("Ihnen stehen folgende Befehle zur Verfügung:");
parser.zeigeBefehle();
}
/**
* Versuche, in eine Richtung zu gehen. Wenn es einen Ausgang gibt,
* wechsele in den neuen Raum, ansonsten gib eine Fehlermeldung
* aus.
*/
private void wechsleRaum(Befehl befehl)
{
if(!befehl.hatZweitesWort()) {
// Gibt es kein zweites Wort, wissen wir nicht, wohin...
System.out.println("Wohin möchten Sie gehen?");
return;
}
String richtung = befehl.gibZweitesWort();
// Wir versuchen, den Raum zu verlassen.
Raum naechsterRaum = aktuellerRaum.gibAusgang(richtung);
if (naechsterRaum == null) {
System.out.println("Dort ist keine Tür!");
}
else {
aktuellerRaum = naechsterRaum;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
}
/**
* "quit" wurde eingegeben. Überprüfe den Rest des Befehls,
* ob das Spiel wirklich beendet werden soll.
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean beenden(Befehl befehl)
{
if(befehl.hatZweitesWort()) {
System.out.println("Was soll beendet werden?");
return false;
}
else {
return true; // Das Spiel soll beendet werden.
}
}
}
import java.util.Set;
import java.util.HashMap;
import java.util.ArrayList;
/**
* Diese Klasse modelliert Räume in der Welt von Zuul.
*
* Ein "Raum" repräsentiert einen Ort in der virtuellen Landschaft des
* Spiels. Ein Raum ist mit anderen Räumen über Ausgänge verbunden.
* Für jeden existierenden Ausgang hält ein Raum eine Referenz auf
* den benachbarten Raum.
*
* @author Michael Kölling und David J. Barnes
* @version 31.07.2011
*/
class Raum
{
private String beschreibung;
private HashMap<String, Raum> ausgaenge; // die Ausgänge dieses Raums
private Raum aktuellerRaum;
private ArrayList<Gegenstand> gegenstaende;
/**
* Erzeuge einen Raum mit einer Beschreibung. Ein Raum
* hat anfangs keine Ausgänge.
* @param beschreibung enthält eine Beschreibung in der Form
* "in einer Küche" oder "auf einem Sportplatz".
*/
public Raum(String beschreibung)
{
this.beschreibung = beschreibung;
ausgaenge = new HashMap<String, Raum>();
gegenstaende = new ArrayList<Gegenstand>();
}
public String gibBeschreibung()
{
return beschreibung;
}
public void addGegenstand(Gegenstand gegenstand)
{
gegenstaende.add(gegenstand);
}
/**
* Definiere einen Ausgang für diesen Raum.
* @param richtung die Richtung, in der der Ausgang liegen soll
* @param nachbar der Raum, der über diesen Ausgang erreicht wird
*/
public void setzeAusgang(String richtung, Raum nachbar)
{
ausgaenge.put(richtung, nachbar);
}
/**
* @return die kurze Beschreibung dieses Raums (die dem Konstruktor
* übergeben wurde).
*/
public String gibKurzbeschreibung()
{
return beschreibung;
}
/**
* Liefere eine lange Beschreibung dieses Raums, in der Form:
* Sie sind in der Küche.
* Ausgänge: nord west
* @return eine lange Beschreibung dieses Raumes.
*/
public String gibLangeBeschreibung()
{
return "Sie sind " + beschreibung + ".\n" + gibAusgaengeAlsString();
}
public String gibEssensBeschreibung()
{
return "Sie haben nun gegessen und sind nicht mehr hungrig!";
}
public String gibAusgaengeAlsString2()
{
String ergebnis = "Ausgänge: ";
if (aktuellerRaum.gibAusgang("north") != null) {
ergebnis += "north";
if (aktuellerRaum.gibAusgang("east") != null) {
ergebnis += "east";
if (aktuellerRaum.gibAusgang("south") != null) {
ergebnis += "south";
if (aktuellerRaum.gibAusgang("west") != null) {
ergebnis += "west";
}
}
}
}
return ergebnis;
}
/**
* Liefere eine Beschreibung der Ausgänge dieses Raumes,
* beispielsweise
* "Ausgänge: north west".
* @return eine Beschreibung der Ausgänge dieses Raumes.
*/
private String gibAusgaengeAlsString()
{
String ergebnis = "Ausgänge:";
Set<String> keys = ausgaenge.keySet();
for(String ausgang : keys)
ergebnis += " " + ausgang;
return ergebnis;
}
public Raum gibAusgang(String richtung)
{
return ausgaenge.get(richtung);
}
/**
* Liefere den Raum, den wir erreichen, wenn wir aus diesem Raum
* in die angegebene Richtung gehen. Liefere 'null', wenn in
* dieser Richtung kein Ausgang ist.
* @param richtung die Richtung, in die gegangen werden soll.
* @return den Raum in der angegebenen Richtung.
*/
}
Dabei kommt kein Fehler?Java:keller = gegenstaende.addGegenstand( Gegenstand("Buch", 150)); buero = gegenstaende.addGegenstand(new Gegenstand("Computer", 1500));
und in deiner main wo du die Räume Ausgänge etc. erzeugst da legst du einen Computer mit new an und fügst ihn dem gewünschten Raum mit addGegenstand(..) dazu
/**
* Dies ist die Hauptklasse der Anwendung "Die Welt von Zuul".
* "Die Welt von Zuul" ist ein sehr einfaches, textbasiertes
* Adventure-Game. Ein Spieler kann sich in einer Umgebung bewegen,
* mehr nicht. Das Spiel sollte auf jeden Fall ausgebaut werden,
* damit es interessanter wird!
*
* Zum Spielen muss eine Instanz dieser Klasse erzeugt werden und
* an ihr die Methode "spielen" aufgerufen werden.
*
* Diese Instanz dieser Klasse erzeugt und initialisiert alle
* anderen Objekte der Anwendung: Sie legt alle Räume und einen
* Parser an und startet das Spiel. Sie wertet auch die Befehle
* aus, die der Parser liefert und sorgt für ihre Ausführung.
*
* @author Michael Kölling und David J. Barnes
* @version 31.07.2011
*/
import java.util.ArrayList;
class Spiel
{
private Parser parser;
private Raum aktuellerRaum;
private Gegenstand aktuellerGegenstand;
private ArrayList<Gegenstand> gegenstaende;
private Gegenstand buch;
private Gegenstand computer;
/**
* Erzeuge ein Spiel und initialisiere die interne Raumkarte.
*/
public Spiel()
{
raeumeAnlegen();
parser = new Parser();
}
/**
* Erzeuge alle Räume und verbinde ihre Ausgänge miteinander.
*/
private void raeumeAnlegen()
{
Raum draussen, hoersaal, cafeteria, labor, buero, keller;
// die Räume erzeugen
draussen = new Raum("vor dem Haupteingang der Universität");
hoersaal = new Raum("in einem Vorlesungssaal");
cafeteria = new Raum("in der Cafeteria der Uni");
labor = new Raum("in einem Rechnerraum");
buero = new Raum("im Verwaltungsbüro der Informatik");
keller = new Raum("im Keller");
// die Ausgänge initialisieren
draussen.setzeAusgang("east", hoersaal);
draussen.setzeAusgang("south", labor);
draussen.setzeAusgang("west", cafeteria);
hoersaal.setzeAusgang("west", draussen);
cafeteria.setzeAusgang("east", draussen);
labor.setzeAusgang("north", draussen);
labor.setzeAusgang("east", buero);
buero.setzeAusgang("west", labor);
buero.setzeAusgang("down", keller);
keller.setzeAusgang("up", buero);
//Gegenstände erzeugen
buch = new Gegenstand("Buch", 150);
computer = new Gegenstand("Computer", 1500);
keller.addGegenstand(buch);
buero.addGegenstand(computer);
aktuellerRaum = draussen; // das Spiel startet draussen
}
/**
* Die Hauptmethode zum Spielen. Läuft bis zum Ende des Spiels
* in einer Schleife.
*/
public void spielen()
{
willkommenstextAusgeben();
// Die Hauptschleife. Hier lesen wir wiederholt Befehle ein
// und führen sie aus, bis das Spiel beendet wird.
boolean beendet = false;
while (! beendet) {
Befehl befehl = parser.liefereBefehl();
beendet = verarbeiteBefehl(befehl);
}
System.out.println("Danke für dieses Spiel. Auf Wiedersehen.");
}
private void umsehen()
{
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
private void essen()
{
System.out.println(aktuellerRaum.gibEssensBeschreibung());
}
private void rauminfoAusgeben()
{
System.out.println("Sie sind " + aktuellerRaum.gibBeschreibung());
System.out.print("Ausgänge: ");
if (aktuellerRaum.gibAusgang("north") != null) {
System.out.print("north ");
}
if(aktuellerRaum.gibAusgang("east") != null) {
System.out.print("east ");
}
if(aktuellerRaum.gibAusgang("south") != null) {
System.out.print("south ");
}
if(aktuellerRaum.gibAusgang("west") != null) {
System.out.print("west ");
}
System.out.println();
}
/**
* Einen Begrüßungstext für den Spieler ausgeben.
*/
private void willkommenstextAusgeben()
{
System.out.println();
System.out.println("Willkommen zu Zuul!");
System.out.println("Zuul ist ein neues, unglaublich langweiliges Spiel.");
System.out.println("Tippen sie 'help', wenn Sie Hilfe brauchen.");
System.out.println();
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
/**
* Verarbeite einen gegebenen Befehl (führe ihn aus).
* @param befehl Der zu verarbeitende Befehl.
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean verarbeiteBefehl(Befehl befehl)
{
boolean moechteBeenden = false;
if(befehl.istUnbekannt()) {
System.out.println("Ich weiss nicht, was Sie meinen...");
return false;
}
String befehlswort = befehl.gibBefehlswort();
if (befehlswort.equals("help")) {
hilfstextAusgeben();
}
else if (befehlswort.equals("go")) {
wechsleRaum(befehl);
}
else if (befehlswort.equals("look")) {
umsehen();
}
else if (befehlswort.equals("eat")) {
essen();
}
else if (befehlswort.equals("quit")) {
moechteBeenden = beenden(befehl);
}
// ansonsten: Befehl nicht erkannt.
return moechteBeenden;
}
// Implementierung der Benutzerbefehle:
/**
* Gib Hilfsinformationen aus.
* Hier geben wir eine etwas alberne und unklare Beschreibung
* aus, sowie eine Liste der Befehlswörter.
*/
private void hilfstextAusgeben()
{
System.out.println("Sie haben sich verlaufen. Sie sind allein.");
System.out.println("Sie irren auf dem Unigelände herum.");
System.out.println();
System.out.println("Ihnen stehen folgende Befehle zur Verfügung:");
parser.zeigeBefehle();
}
/**
* Versuche, in eine Richtung zu gehen. Wenn es einen Ausgang gibt,
* wechsele in den neuen Raum, ansonsten gib eine Fehlermeldung
* aus.
*/
private void wechsleRaum(Befehl befehl)
{
if(!befehl.hatZweitesWort()) {
// Gibt es kein zweites Wort, wissen wir nicht, wohin...
System.out.println("Wohin möchten Sie gehen?");
return;
}
String richtung = befehl.gibZweitesWort();
// Wir versuchen, den Raum zu verlassen.
Raum naechsterRaum = aktuellerRaum.gibAusgang(richtung);
if (naechsterRaum == null) {
System.out.println("Dort ist keine Tür!");
}
else {
aktuellerRaum = naechsterRaum;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
}
/**
* "quit" wurde eingegeben. Überprüfe den Rest des Befehls,
* ob das Spiel wirklich beendet werden soll.
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean beenden(Befehl befehl)
{
if(befehl.hatZweitesWort()) {
System.out.println("Was soll beendet werden?");
return false;
}
else {
return true; // Das Spiel soll beendet werden.
}
}
}
Erscheint mir unlogisch. Besser fände ich es, wenn bei Eingabe des Befehls "look" die Infos ausgegeben werden würden. Die Eingabe von "look" ruft die Methode umsehen auf, und die wiederum aktuellerRaum.gibLangeBeschreibung(). Ich würde die Ausgabe der in einem Raum enthalteten Gegenstände demnach in die Methode gibLangeBeschreibung() der Klasse Raum packen.Jetzt soll es so sein, dass angezeigt werden soll, welcher Gegenstand sich im Raum befindet, wenn man
eben diesen Raum betritt.
public String gibLangeBeschreibung()
{
return "Sie sind " + beschreibung + ".\n" + gibAusgaengeAlsString();
}
Was willst du mit dem Code erreichen?Java:public void addGegenstand(Gegenstand gegenstand) { gegenstaende.add(new Gegenstand("Buch", 150)); gegenstaende.add(new Gegenstand("Computer", 1500)); }
Das ist aber nicht Sinn der Methode. Der Sinn der Methode besteht darin, den an die Methode übergebenen Gegenstand in die gegenstaende-ArrayList aufzunehmen. Du ignorierst aber den übergebenen Gegenstand, und fügst stattdessen bei jedem Aufruf von addGegenstand ein Buch und einen Computer hinzu.Dass Gegenstände in eine ArrayList aufgenommen werden.
public void addGegenstand(Gegenstand gegenstand)
{
gegenstaende.add(gegenstand);
}
//Gegenstände erzeugen
buch = new Gegenstand("Buch", 150);
computer = new Gegenstand("Computer", 1500);
keller.addGegenstand(buch);
buero.addGegenstand(computer);
Nein wird es nicht. Es wird zum Keller ein Buch hinzugefügt und zum Buero ein Computer. Du hast doch selber den relevanten Code gepostet:Ich weiss, wenn die Methode addGegenstand aufgerufen wird, wird IMMER ein Buch UND Computer hinzugefügt.
//Gegenstände erzeugen
buch = new Gegenstand("Buch", 150);
computer = new Gegenstand("Computer", 1500);
keller.addGegenstand(buch);
buero.addGegenstand(computer);
public void gegenstaendeAnzeigen()
{
for(Gegenstand aktuellerGegenstand: gegenstaende){
System.out.println(aktuellerGegenstand. ());
}