Wollte eine Falltür machen mit der ich an den Anfang (draussen) gesetzt werde.
Leider stehe ich grad ein wenig auf dem Schlauch und versteh nicht was ich vergesse bzw anders machen soll
Kann jemand helfen?
Leider stehe ich grad ein wenig auf dem Schlauch und versteh nicht was ich vergesse bzw anders machen soll
Kann jemand helfen?
Java:
import java.util.Stack;
/**
* 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 Stack<Raum> backStack;
private Player player;
/**
* Erzeuge ein Spiel und initialisiere die interne Raumkarte.
*/
public Spiel() {
raeumeAnlegen();
parser = new Parser();
this.player = new Player("Player");
this.backStack = new Stack<Raum>();
}
/**
* Erzeuge alle Räume und verbinde ihre Ausgänge miteinander.
*/
private void raeumeAnlegen() {
Raum draussen, halle, kueche, verlies, waffenkammer, speisesaal, speisekammer, treppe, leererraum;
// die Räume erzeugen
draussen = new Raum("vor dem Haupteingang einer alten Burg");
halle = new Raum("in einer großen Halle");
kueche = new Raum("in der Küche");
verlies = new Raum("in einem einem alten Verlies");
waffenkammer = new Raum("in der Waffenkammer der Burg");
speisekammer = new Raum("in der Speisekammer");
speisesaal = new Raum("im Speisesaal der Burg");
treppe = new Raum("an einer Treppe");
leererraum = new Raum("in einem leeren Raum");
// die Ausgänge initialisieren
draussen.setzeAusgang("north", halle);
halle.setzeAusgang("south", draussen);
halle.setzeAusgang("west", speisesaal);
halle.setzeAusgang("east", leererraum);
speisesaal.setzeAusgang("west", kueche);
speisesaal.setzeAusgang("east", halle);
speisesaal.ausgangSperren("west");
kueche.setzeAusgang("east", speisesaal);
kueche.setzeAusgang("west", speisekammer);
kueche.addPlayer("prinzessin");
speisekammer.setzeAusgang("east", kueche);
verlies.setzeAusgang("south", treppe);
verlies.addItem("Schlüssel", "Das ist ein magischer Schlüssel!", 5);
leererraum.setzeAusgang("west", halle);
leererraum.setzeAusgang("north", treppe);
leererraum.addItem("Krug", "Ein goldener krug!", 7);
leererraum.falltuerAktivieren("north");
treppe.setzeAusgang("north", verlies);
treppe.setzeAusgang("south", leererraum);
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);
}
}
/**
* Einen Begrüßungstext für den Spieler ausgeben.
*/
private void willkommenstextAusgeben() {
System.out.println();
System.out.println("Willkommen zum langweilsten Spiel der Welt!");
System.out.println("Die Prinzessin ist verschwunden. Kannst du Sie finden?");
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")) {
moechteBeenden = wechsleRaum(befehl);
} else if (befehlswort.equals("quit")) {
moechteBeenden = beenden(befehl);
} else if (befehlswort.equals("look")) {
umsehen();
} else if(befehlswort.equals("take")) {
this.takeItem(befehl);
} else if(befehlswort.equals("list")) {
this.listInventar();
}
// 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 ist in dieser Burg! Finde Sie!");
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 boolean wechsleRaum(Befehl befehl) {
if(!befehl.hatZweitesWort()) {
// Gibt es kein zweites Wort, wissen wir nicht, wohin...
System.out.println("Wohin möchten Sie gehen?");
return false;
} else {
String richtung = befehl.gibZweitesWort();
if(richtung.equals("back")) {
back();
return false;
} else {
// Wir versuchen, den Raum zu verlassen.
Raum naechsterRaum = aktuellerRaum.gibAusgang(richtung);
if (naechsterRaum == null) {
System.out.println("Dort ist keine Durchgang!");
return false;
} else if(naechsterRaum.getLocked()) {
if(this.player.hasItem("Schlüssel")) {
aktuellerRaum.ausgangOeffnen(richtung);
System.out.println("Der Ausgang Richtung " + richtung + " wurde geoeffnet!");
backStack.push(aktuellerRaum);
aktuellerRaum = naechsterRaum;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
if(aktuellerRaum.hasPrincess()) {
System.out.println("Herzlichen Glückwunsch, Sie haben die Prinzessin gefunden!");
System.out.println("Das Spiel ist damit beendet.");
return true;
} else {
return false;
}
} else {
System.out.println("Dieser Durchgang ist versperrt! Sie benötigen einen Schlüssel!");
return false;
}
} else if(naechsterRaum.getFalltuer()) {
if(this.player.hasItem("Krug")) {
aktuellerRaum.falltuerDeaktivieren(richtung);
System.out.println("Der Mechanismus zum Teleportieren wurde deaktiviert!");
backStack.push(aktuellerRaum);
aktuellerRaum = naechsterRaum;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
} else {
System.out.println("Oh Nein! Sie wurden zum Anfang telportiert. Vielleicht kann etwas den Mechanismus blockieren?");
aktuellerRaum = back;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
} else {
backStack.push(aktuellerRaum);
aktuellerRaum = naechsterRaum;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
return false;
}
}
}
return false;
}
/**
* "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.
}
}
private void umsehen() {
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
private void takeItem(Befehl befehl) {
if(!befehl.hatZweitesWort()) {
// Gibt es kein zweites Wort, wissen wir nicht, wohin...
System.out.println("Was möchten Sie nehmen?");
} else {
String gegenstand = befehl.gibZweitesWort();
// Wir versuchen, den Raum zu verlassen.
Item item = aktuellerRaum.getItem(gegenstand);
if (item == null) {
System.out.println("Dieser Gegenstand konnte nicht gefunden werden!");
} else {
if(this.player.addItem(item)) {
aktuellerRaum.removeItem(item.getName());
System.out.println(aktuellerRaum.gibLangeBeschreibung());
} else {
System.out.println("Der Gegenstand ist zu schwer für Ihr Inventar!");
}
}
}
}
/*
* Nennt den Inhalt von Ihrem Inventar.
*/
private void listInventar() {
if(this.player.getInventar().size() > 0) {
System.out.println("Ihr Inventar enthält:");
int weight = 0;
for(String item : this.player.getInventar().keySet()) {
System.out.println(item);
weight += this.player.getInventar().get(item).getGewicht();
}
System.out.println("Sie haben noch " + (this.player.getMaxWeight() - weight) + " Plätze verfügbar.");
} else {
System.out.println("Ihr Inventar ist momentan leer!");
System.out.println("Sie haben noch " + this.player.getMaxWeight() + " Plätze verfügbar.");
}
}
/**
* Gehe in den vorherigen Raum zurück.
*/
private void back() {
if(backStack.empty() == true){
System.out.println("Du bist bereits am Anfang.");
System.out.println(aktuellerRaum.gibLangeBeschreibung());
} else {
System.out.println("Du bist im vorherigen Raum.");
aktuellerRaum = backStack.pop();
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
}
}
Java:
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
*/
public class Raum {
private String beschreibung;
private HashMap<String, Raum> ausgaenge; // die Ausgänge dieses Raums
private HashMap<String, Item> itemList;
private HashMap<String, Player> playerList;
private boolean isLocked;
private boolean isTrapped;
/**
* 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;
this.ausgaenge = new HashMap<String, Raum>();
this.itemList = new HashMap<String, Item>();
this.playerList = new HashMap<String, Player>();
this.isLocked = false;
this.isTrapped = false;
}
/**
* 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);
}
/**
* Sperrt einen Ausgang.
*/
public boolean ausgangSperren(String beschreibung) {
if(ausgaenge.containsKey(beschreibung)) {
ausgaenge.get(beschreibung).sperren();
return true;
} else {
return false;
}
}
/**
* Öffnet den gesperrten Ausgang.
*/
public boolean ausgangOeffnen(String beschreibung) {
if(ausgaenge.containsKey(beschreibung)) {
ausgaenge.get(beschreibung).oeffnen();
return true;
} else {
return false;
}
}
private void sperren() {
this.isLocked = true;
}
private void oeffnen() {
this.isLocked = false;
}
public boolean getLocked() {
return this.isLocked;
}
/**
* Aktiviert die Falltür.
*/
public boolean falltuerAktivieren(String beschreibung) {
if(ausgaenge.containsKey(beschreibung)) {
ausgaenge.get(beschreibung).aktivieren();
return true;
} else {
return false;
}
}
/**
* Deaktiviert die Falltür.
*/
public boolean falltuerDeaktivieren(String beschreibung) {
if(ausgaenge.containsKey(beschreibung)) {
ausgaenge.get(beschreibung).deaktivieren();
return true;
} else {
return false;
}
}
private void aktivieren() {
this.isTrapped = true;
}
private void deaktivieren() {
this.isTrapped = false;
}
public boolean getFalltuer() {
return this.isTrapped;
}
/**
* @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() + "\n" + gibItemsAlsString();
}
/**
* 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;
}
private String gibItemsAlsString() {
String ergebnis = "Verfügbare Items: ";
Set<String> keys = itemList.keySet();
if(keys.size() == 0) {
ergebnis += "Keine";
} else {
for(String item : keys) {
ergebnis += " " + itemList.get(item).getName() + ", Gewicht: " + itemList.get(item).getGewicht();
}
}
return ergebnis;
}
public boolean hasPrincess() {
Set<String> keys = playerList.keySet();
if(keys.size() == 0) {
return false;
} else {
for(String player : keys) {
if(player.equals("prinzessin")) {
return true;
}
}
return false;
}
}
/**
* 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.
*/
public Raum gibAusgang(String richtung) {
return ausgaenge.get(richtung);
}
/**
* Fügt Räumen bestimmte Items zu.
* @param item Das Item, das dem Raum hinzugefügt werden soll.
*/
public void addItem(String name, String beschreibung, int gewicht) {
itemList.put(name, new Item(name, beschreibung, gewicht));
}
public Item getItem(String beschreibung) {
if(itemList.containsKey(beschreibung)) {
return itemList.get(beschreibung);
} else {
return null;
}
}
public boolean removeItem(String beschreibung) {
if(itemList.containsKey(beschreibung)) {
itemList.remove(beschreibung);
return true;
} else {
return false;
}
}
public void addPlayer(String name) {
playerList.put(name, new Player(name));
}
public Player getPlayer(String name) {
if(playerList.containsKey(name)) {
return playerList.get(name);
} else {
return null;
}
}
}
Zuletzt bearbeitet von einem Moderator:
