Hallo,
Wie schreibe ich die Methode
raumZurueck2() ?
Wie kommen die Räume, die man nacheinander betritt, in den Stack hinein?
Das ist das Hauptproblem, das ich habe!
Es soll so sein, dass man jedes Mal, wenn man den Befehl "back" eingibt einen Raum zurückgeht. Das heisst, wenn man "back" oft genug hintereinander eingibt,
soll man ans Spielende zurückversetzt werden!
Klasse Spiel:
Klasse Raum:
Auszug aus der Klasse Spiel:
Push() fügt Elemente hinzu, Pop() löscht Elemente .
Im Moment ist es so, dass nur der letzte Raum, den man betritt, gelöscht wird.
Es ist aber nicht möglich, mehr als einen Raum zurückzugehen!
Kann mir da jemand bitte helfen?
Dass mehr als ein Raum den man betritt, gelöscht wird?
Ich weiss nicht, wie ich die Räume, die man nacheinander durchläuft, in den Stack
mit der push.Methode hineintut!
Infos:
https://www.callicoder.com/java-stack/
https://www.geeksforgeeks.org/stack-pop-method-in-java/
Alleine schaffe ich es leider nicht -.- hab schon vieles versucht
Konsole:
https://imgur.com/a/kJWHOZ5
Wie schreibe ich die Methode
raumZurueck2() ?
Wie kommen die Räume, die man nacheinander betritt, in den Stack hinein?
Das ist das Hauptproblem, das ich habe!
Es soll so sein, dass man jedes Mal, wenn man den Befehl "back" eingibt einen Raum zurückgeht. Das heisst, wenn man "back" oft genug hintereinander eingibt,
soll man ans Spielende zurückversetzt werden!
Klasse Spiel:
Code:
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
class Spiel
{
private Parser parser = new Parser();
private Raum aktuellerRaum;
private Raum letzterRaum;
private List<Gegenstand> inventar = new ArrayList<Gegenstand>();
private int maximaleTragkraft = 10000;
// private String name;
private Stack<String> stackOfRooms;
/**
* Erzeuge ein Spiel und initialisiere die interne Raumkarte.
*/
public Spiel()
{
raeumeAnlegen();
stackOfRooms = new Stack<>();
}
/**
* Erzeuge alle Räume und verbinde ihre Ausgänge miteinander.
*/
private void raeumeAnlegen()
{
// die Räume erzeugen
Raum draussen = new Raum("vor dem Haupteingang der Universität");
Raum hoersaal = new Raum("in einem Vorlesungssaal");
Raum cafeteria = new Raum("in der Cafeteria der Uni");
Raum labor = new Raum("im Labor");
Raum buero = new Raum("im Verwaltungsbüro der Informatik");
Raum keller = new Raum("im Keller");
Raum teleporterRaum = new TeleporterRaum(buero, keller);
// die Ausgänge initialisieren
draussen.setzeAusgang("east", hoersaal);
draussen.setzeAusgang("south", labor);
draussen.setzeAusgang("west", cafeteria);
draussen.setzeAusgang("north", teleporterRaum);
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
draussen.addGegenstand(new Gegenstand("Rucksack",100,10000));
keller.addGegenstand(new Gegenstand("Buch", 150));
buero.addGegenstand(new Gegenstand("Computer", 1500));
labor.addGegenstand(new Gegenstand("Nitroglyzerin",4999));
labor.addGegenstand(new Gegenstand("Schwefel",2));
labor.addGegenstand(new Gegenstand("Eisenstange",11000));
labor.addGegenstand(new Gegenstand("Erlenmayerkolben",4999));
labor.addGegenstand(new Gegenstand("Luftballon",1));
aktuellerRaum = draussen; // das Spiel startet draussen
}
private int berechneInventarGewicht(){
int gesamtGewicht = 0;
for(Gegenstand aktuellerGegenstand: inventar){
gesamtGewicht += aktuellerGegenstand.gibGegenstandGewicht();
}
return gesamtGewicht;
}
private boolean istAufhebbar(Gegenstand gegenstand)
{
int gegenstandsgewicht = gegenstand.gibGegenstandGewicht();
int freierPlatz = maximaleTragkraft - berechneInventarGewicht();
return freierPlatz >= gegenstandsgewicht;
}
/**
* 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());
System.out.println(aktuellerRaum.gibGegenstaendeAlsString());
}
private void essen()
{
System.out.println(aktuellerRaum.gibEssensBeschreibung());
}
private void nimmGegenstand(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();
Raum naechsterRaum = aktuellerRaum.gibAusgang(richtung);
if (naechsterRaum == null) {
System.out.println("Dort ist keine Tür!");
}
else {
aktuellerRaum = naechsterRaum;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
}
private void befehlTake(Befehl befehl)
{
String name = befehl.gibZweitesWort();
Gegenstand gegenstand = aktuellerRaum.findeGegenstand(name);
if(gegenstand == null){
System.out.println("Es gibt keine Gegenstände mit dem Namen "+name+" in diesem Raum.");
}else{
//überprüfe, ob genügend freie Tragfähigkeit.
if(istAufhebbar(gegenstand)){
System.out.println("Sie haben den Gegenstand hochgehoben!");
System.out.println("Er hat folgende Beschreibung: "+ gegenstand.gibBeschreibung());
inventar.add(gegenstand);
maximaleTragkraft += gegenstand.gibTragekapazitaet();
aktuellerRaum.entferneGegenstand(gegenstand);
}else{
System.out.println("Der Gegenstand ist zu schwer. Er wiegt: "+ gegenstand.gibGegenstandGewicht());
System.out.println("Du benötigst mehr Tragkraft.");
}
}
System.out.println();
}
private void befehlStatus(){
System.out.println("Dein Inventar ist zu "+berechneInventarGewicht()+" / "+ maximaleTragkraft +" gefüllt.");
if(inventar.size() > 0){
System.out.println("Du besitzt folgende "+ inventar.size() + " Gegenstände:");
for(Gegenstand aktuellerGegenstand : inventar){
System.out.println(aktuellerGegenstand.gibBeschreibung()+" ("+aktuellerGegenstand.gibGegenstandGewicht()+")");
}
}else{
System.out.println("Du besitzt keine Gegenstände.");
}
}
private Gegenstand findeImInventar(String name) {
for(Gegenstand gegenstand : inventar){
if(gegenstand.gibBeschreibung().equals(name)) {
return gegenstand;
}
}
return null;
}
/*private boolean istImInventar(String name) {
for(Gegenstand gegenstand : inventar){
if(gegenstand.gibBeschreibung().equals(name)) {
return true;
}
}
return false;
}
private void entferneGegenstand(String name) {
Gegenstand gesucht = null;
for(Gegenstand gegenstand : inventar){
if(gegenstand.gibBeschreibung().equals(name)) {
gesucht = gegenstand;
break;
}
}
inventar.remove(gesucht);
}*/
private void befehlDrop(Befehl befehl){
String name = befehl.gibZweitesWort();
/*if(istImInventar(gegenstand)){
entferneGegenstand(gegenstand);*/
Gegenstand gegenstand = findeImInventar(name);
if(gegenstand != null){
inventar.remove(gegenstand);
maximaleTragkraft -= gegenstand.gibTragekapazitaet();
aktuellerRaum.addGegenstand(gegenstand);
System.out.println("Der Gegenstand " +name+ " wurde zurückgelegt!");
}else{
System.out.println("Du besitzt diesen Gegenstand nicht");
}
}
/* private void rauminfoAusgeben()
{
System.out.println("Sie sind " + aktuellerRaum.gibBeschreibung());
//System.out.println("Hier befinden sich folgende Gegestände:");
//System.out.println(aktuellerRaum.gibGegenstaendeAlsString());
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("back")) {
//raumZurueck();
raumZurueck2();
}
else if (befehlswort.equals("take")) {
befehlTake(befehl);
}
else if (befehlswort.equals("status")) {
befehlStatus();
}
else if (befehlswort.equals("drop")){
befehlDrop(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;
}
if(maximaleTragkraft < berechneInventarGewicht()){
System.out.println("Es ist zu schwer, du kannst dich nicht mehr bewegen");
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 {
letzterRaum = aktuellerRaum;
aktuellerRaum = naechsterRaum;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
}
/* private void raumZurueck()
{
if (letzterRaum != null) {
aktuellerRaum = letzterRaum;
letzterRaum = null;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
}
*/
private void raumZurueck2()
{
stackOfRooms.push(letzterRaum.gibBeschreibung());
System.out.println("Stack :" + stackOfRooms);
stackOfRooms.pop();
System.out.println("Current Stack : " + stackOfRooms);
}
/**
* "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.
}
}
}
Klasse Raum:
Code:
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;
protected HashMap<String, Raum> ausgaenge; // die Ausgänge dieses Raums
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);
}
public void entferneGegenstand(Gegenstand gegenstand){
gegenstaende.remove(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 Gegenstand findeGegenstand(String name) {
for(Gegenstand aktuellerGegenstand: gegenstaende){
if (aktuellerGegenstand.gibBeschreibung().equals (name)) {
return aktuellerGegenstand;
}
}
return null;
}
/*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 String gibGegenstaendeAlsString()
{
String ergebnis = "";
for(Gegenstand aktuellerGegenstand : gegenstaende){
ergebnis += aktuellerGegenstand.gibBeschreibung() + " ("+aktuellerGegenstand.gibGegenstandGewicht()+") \n";
}
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.
*/
}
Auszug aus der Klasse Spiel:
Code:
private void raumZurueck2()
{
stackOfRooms.push(letzterRaum.gibBeschreibung());
System.out.println("Stack :" + stackOfRooms);
stackOfRooms.pop();
System.out.println("Current Stack : " + stackOfRooms);
}
Push() fügt Elemente hinzu, Pop() löscht Elemente .
Im Moment ist es so, dass nur der letzte Raum, den man betritt, gelöscht wird.
Es ist aber nicht möglich, mehr als einen Raum zurückzugehen!
Kann mir da jemand bitte helfen?
Dass mehr als ein Raum den man betritt, gelöscht wird?
Ich weiss nicht, wie ich die Räume, die man nacheinander durchläuft, in den Stack
mit der push.Methode hineintut!
Infos:
https://www.callicoder.com/java-stack/
https://www.geeksforgeeks.org/stack-pop-method-in-java/
Alleine schaffe ich es leider nicht -.- hab schon vieles versucht
Konsole:
https://imgur.com/a/kJWHOZ5
Zuletzt bearbeitet: