Erste Schritte Stack im Rollenspiel

Devanther

Top Contributor
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:
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:

mihe7

Top Contributor
Irgendwie verstehe ich das Problem nicht ganz. Im Endeffekt hast Du z. B. folgendes Schema:
Java:
Stack<Raum> weg = new Stack<>();

public void vorwaerts() {
    weg.push(aktuellerRaum);
    aktuellerRaum = naechsterRaum;
}

public void zurueck() {
    aktuellerRaum = weg.pop();
}
 

Devanther

Top Contributor
wenn ich das so eingebe, bekomm ich die ganzen Fehlermeldungen nicht weg,
aktueller Raum und naechster Raum erscheinen rot..!

Code:
public void raumZurueck3() {
    stackOfRooms.push(aktuellerRaum);
    aktuellerRaum = naechsterRaum;
    aktuellerRaum = stackOfRooms.pop();
   
    System.out.println("Current Stack : " + stackOfRooms);
  
    }
 
Zuletzt bearbeitet:

Devanther

Top Contributor
Code:
private void zurueck3() {
 
   
   stackOfRooms.push(aktuellerRaum);
    aktuellerRaum = naechsterRaum;
    aktuellerRaum = stackOfRooms.pop();
 
    System.out.println("Current Stack : " + aktuellerRaum);
    }

Es geht nicht.

private Stack<Raum> stackOfRooms; und dann im Konstruktor aufgerufen.
Da ändert sich nicht viel.
 

Meniskusschaden

Top Contributor
Was soll sich da auch ändern? Du legst den aktuellen Raum auf den Stapel, setzt ihn dann kurz auf den nächsten Raum, um ihn unmittelbar danach wieder auf den gerade im Stapel abgelegten Raum zurück zu setzen - also denselben, in dem du beim Methodenstart sowieso gerade warst. Unter'm Strich machst du mit den drei Anweisungen also gar nichts.

Mit
Immer, wenn Du einen Raum verlässt,
war bestimmt nicht das "Verlassen" beim zurück gehen gemeint, sondern beim vorwärts gehen.
 

mihe7

Top Contributor
war bestimmt nicht das "Verlassen" beim zurück gehen gemeint, sondern beim vorwärts gehen.
So ist es.

Ich kann Schritt 2 und 3 nicht in Code umwandeln!
Das ist doch nicht so schwer: an jeder Stelle, an der Du von einem Raum in den nächsten wechselst, fügst Du den Raum, den Du verlassen hast, zum Stack dazu.

Zum Beispiel:
Start: Raum1, Stack = {}
1. Gehe zu Raum2: Stack = {Raum1}, aktuellerRaum = Raum2
2. Gehe zu Raum3: Stack = {Raum1, Raum2}, aktuellerRaum = Raum3
3. Gehe zu Raum2: Stack = {Raum1, Raum2, Raum3}, aktuellerRaum = Raum2

Wenn Du jetzt einen Schritt rückgängig machen willst, holst Du den jeweils letzten Raum vom Stack.

4. Zurück: aktuellerRaum = Stack.pop() = Raum3, Stack = {Raum1, Raum2}
5. Zurück: aktuellerRaum = Stack.pop() = Raum2, Stack = {Raum1}
 

Javinner

Top Contributor
Mein lieber @Devanther wir haben 2019..
Java:
public class Raeume2019
{

    public static void main(String[] args)
    {
        Raum wohnzimmer = new Raum("Wohnzimmer");
        Spieler spieler = new Spieler(wohnzimmer);
        spieler.gebeAktuellenRaumAus();
        spieler.gebeGegangeneStreckeAus();

        Raum kueche = new Raum("Kueche");
        spieler.wechseleRaum(kueche);
        spieler.gebeAktuellenRaumAus();
        spieler.gebeGegangeneStreckeAus();

        Raum abstellraum = new Raum("Abstellraum");
        spieler.wechseleRaum(abstellraum);
        spieler.gebeAktuellenRaumAus();
        spieler.gebeGegangeneStreckeAus();

        spieler.geheZurueck();
        spieler.gebeAktuellenRaumAus();
        spieler.gebeGegangeneStreckeAus();

        spieler.geheZurueck();
        spieler.gebeAktuellenRaumAus();
        spieler.gebeGegangeneStreckeAus();

        //siehe Methode geheZurueck(), es wartet eine Aufgabe auf dich
    }

}
/** Output */
------------------------------Aktueller Raum
Wohnzimmer
------------------------------Gegangene Strecke
Wohnzimmer
------------------------------Aktueller Raum
Kueche
------------------------------Gegangene Strecke
Wohnzimmer
Kueche
------------------------------Aktueller Raum
Abstellraum
------------------------------Gegangene Strecke
Wohnzimmer
Kueche
Abstellraum
------------------------------Aktueller Raum
Kueche
------------------------------Gegangene Strecke
Wohnzimmer
Kueche
------------------------------Aktueller Raum
Wohnzimmer
------------------------------Gegangene Strecke
Wohnzimmer
Java:
public class Spieler
{

    private Stack<Raum> weg;

    private Raum woBinIch;

    public Spieler(Raum hier)
    {
        weg = new Stack<>();
        weg.add(hier);
        woBinIch = hier;
    }

    public void wechseleRaum(Raum naechsterRaum)
    {
        this.woBinIch = naechsterRaum;
        this.weg.add(naechsterRaum);
    }

    public void gebeAktuellenRaumAus()
    {
        System.out.println("------------------------------Aktueller Raum");
        System.out.println(this.woBinIch.getName());
    }

    /**
     * Aufgabe: Spieler soll den Ersten Raum beim Zurueckgehen nicht loeschen,
     * sondern als den letzten Raum zur Position haben
     */
    public void geheZurueck()
    {
        this.weg.pop();
        this.woBinIch = weg.lastElement();
    }

    public void gebeGegangeneStreckeAus()
    {
        System.out.println("------------------------------Gegangene Strecke");
        this.weg.forEach((r) ->
        {
            System.out.println(r.getName());
        });
    }

}
Java:
public class Raum
{

    private final String name;

    public Raum(String name)
    {
        this.name = name;
    }

    public String getName()
    {
        return name;
    }

}
 

temi

Top Contributor
Kann jemand schreiben, wie die Methode vollständig richtig aussieht?
Wie sieht der Code konkret aus?
Im Beitrag #2 steht alles, was wichtig ist.

Du solltest dein Programm noch mal generell durchsehen, da scheint mir alles etwas durcheinander. Was macht denn "naechsterRaum" in einer Methode zum Nehmen von Gegenständen???
Java:
    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());

        }
    }

Dejavue.. ich logge mich aus, habe weit Besseres zu tun ;) Viel Erfolg

;) Ich kann mich daran erinnern...
 

Devanther

Top Contributor
Mir lässt dieses Problem einfach keine Ruhe!

Code:
private void raumZuruek4()
   {
        if (letzterRaum != null) {
        stackOfRooms.push(letzterRaum);
        System.out.println( " Initial Stack " +stackOfRooms);
        stackOfRooms.pop();
        System.out.println("Stack after : " + stackOfRooms);
      
    }  
   }

wie gehe ich mehrere Räume zurück?
Ich schaff es einfach nicht, Räume in den Stack hinzuzufügen....und auszugeben
Kann mir jemand bitte ne Lösung schreiben, es sind doch nur paar Zeilen Code.
Ich habe es in private Stack<Raum> stackOfRooms; verbessert.

Auch dass was ich oben geschrieben habe, funktioniert nicht,
obwohl es für mich logisch und richtig sein sollte.
 

Javinner

Top Contributor
Java:
public void geheZumRaum(Raum zumRaum)
{
    //Wenn der Raum nicht im Stack, return
    //Wenn der obere Element im Stack == zumRaum : aktueller Raum == obere Element im Stack
    //Wenn nicht, loesche den oberen Element des Stacks
}

public class Raeume2019
{
    public static void main(String[] args)
    {
        Raum wohnzimmer = new Raum("Wohnzimmer");
        Spieler spieler = new Spieler(wohnzimmer);
        spieler.gebeAktuellenRaumAus();
        spieler.gebeGegangeneStreckeAus();
        Raum kueche = new Raum("Kueche");
        spieler.wechseleRaum(kueche);
        spieler.gebeAktuellenRaumAus();
        spieler.gebeGegangeneStreckeAus();
        Raum abstellraum = new Raum("Abstellraum");
        spieler.wechseleRaum(abstellraum);
        spieler.gebeAktuellenRaumAus();
        spieler.gebeGegangeneStreckeAus();

        spieler.geheZumRaum(wohnzimmer); // Here we are
        spieler.gebeAktuellenRaumAus();
        spieler.gebeGegangeneStreckeAus();
    }
}

/** Output */
------------------------------Aktueller Raum
Wohnzimmer
------------------------------Gegangene Strecke
Wohnzimmer
------------------------------Aktueller Raum
Kueche
------------------------------Gegangene Strecke
Wohnzimmer
Kueche
------------------------------Aktueller Raum
Abstellraum
------------------------------Gegangene Strecke
Wohnzimmer
Kueche
Abstellraum
------------------------------Aktueller Raum  //Here we are
Wohnzimmer
------------------------------Gegangene Strecke
Wohnzimmer

.. 5 Minuten ;)
 

mihe7

Top Contributor
Kann mir jemand bitte ne Lösung schreiben, es sind doch nur paar Zeilen Code.
Du hast doch bereits gefühlte 421 Lösungen bekommen. Wo liegt denn das Problem? Wenn Du in einen Raum wechselst, schiebst Du den Raum in den Stack und bei back() holst Du ihn vom Stack. Fertig. Und wenn Du es etwas komfortabler haben willst, nimmst Du den Algorithmus, den @Javinner Dir gerade geschrieben hat.
 

Devanther

Top Contributor
https://imgur.com/fheUZBa

https://imgur.com/a/AadtpDh

Wie man jetzt sehen kann, wird der letzte Raum immer gelöscht.
Man geht also zurück, soweit so gut.

Aber die Namen der Räume werden leider nicht richtig angezeigt....wie ändere ich das?

System.out.println(aktuellerRaum.gibLangeBeschreibung());

Auf dem Stack "stackOfRooms" kann ich leider nicht die .gibLangeBeschreibung() Methode aufrufen,
wie schreibe ich das so, dass die Räume richtig angezeigt werden?
Die Lösung ist sehr sehr nah^^
 

mihe7

Top Contributor
1. schmeiß die Variable letzterRaum ganz aus der Klasse. Der letzte Raum ist derjenige, der ganz oben auf dem Stack liegt.
2. stackOfRooms.push(naechsterRaum) ist falsch. Du musst stackOfRooms.push(aktuellerRaum) gleich am Anfang des else-Zweigs aufrufen.
3. stackOfRooms.pop() alleine bringt Dir wenig, Du musst den vom Stack geholten Raum schon zum aktuellen Raum machen:
Code:
aktuellerRaum = stackOfRooms.pop();
 

mihe7

Top Contributor
Du sollst die beiden System.out.println-Zeilen miteinander vergleichen, insbesondere, wie aktuellerRaum verwendet wird.
 

mihe7

Top Contributor
Ich kann sie Dir auch untereinander schreiben:
Java:
System.out.println(aktuellerRaum.gibLangeBeschreibung());
System.out.println("Stack after: " + aktuellerRaum);
Du wirst doch Unterschiede erkennen können.
 

Devanther

Top Contributor
Also, oben gebe ich vom aktuellen Raum die Methode .gibLangeBeschreibung() aus.
Also eine Beschreibung.
Unten will ich alle Räume vom Stack wiedergeben, wobei der oberste Raum mithilfe der .pop Methode
gelöscht sein soll.
 

mihe7

Top Contributor
Das würde auch funktionieren, wenn Du die toString()-Methode in der Klasse Raum überschrieben hättest.

Meine Frage bezog sich aber darauf, warum Du überhaupt alle Räume des Stacks ausgeben willst.
 

Devanther

Top Contributor
Ich lösche das oberste Element vom Stack und rufe den Stack dann nochmal auf.
Dann müsste das oberste Element gelöscht sein, und man würde sich einen Raum davor befinden.
 

mihe7

Top Contributor
Ich lösche das oberste Element vom Stack und rufe den Stack dann nochmal auf.
Dann müsste das oberste Element gelöscht sein, und man würde sich einen Raum davor befinden.
Die Zeile
Java:
aktuellerRaum = stackOfRooms.pop();
holt (und entfernt) den letzten Raum vom Stack und weist diesen der Variablen aktuellerRaum zu. Nach dieser Zeile befindet sich der Spieler also im "Raum davor".

Wenn Du anschließend anzeigen willst, in welchem Raum sich der Spieler befindet, dann musst Du von aktuellerRaum den Namen anzeigen (System.out.println(aktuellerRaum.gibLangeBeschreibung());)
 

Devanther

Top Contributor
Code:
private void raumZuruek4()
   {

        //System.out.println( " Initial Stack " +stackOfRooms);
        //System.out.println(aktuellerRaum.gibLangeBeschreibung());
       
       
        aktuellerRaum = stackOfRooms.pop();
        if (aktuellerRaum != null) {  
          for (Raum raum : stackOfRooms) {
            System.out.println(raum.gibLangeBeschreibung());
          }
    }   
    }

Jetzt geht es, ist aber immer noch etwas fehlerhaft.
 

mihe7

Top Contributor
Java:
private void raumZuruek4() {
    if (stackOfRooms.isEmpty()) {
        return;
    }

    aktuellerRaum = stackOfRooms.pop();
    for (Raum raum : stackOfRooms) {
        System.out.println(raum.gibLangeBeschreibung());
    }  
}

@DerWissende ich schlafe ja eh schon, bin nur noch nicht im Bett :) Aber gleich.
 
X

Xyz1

Gast
Ich hab zu viel Energy getrunken und kann noch nich schlafen :(:(

@mihe7 Da fällt mir auf das es von der Ablauflogik her nu doch nicht wichtig ist, isEmpty() vorher aufzurufen.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
A stack Java Basics - Anfänger-Themen 14
Proxy Stack erweitern mit neuem Array falls der alte voll ist!? Java Basics - Anfänger-Themen 5
V Ist Off-Heap-Speicher dasselbe wie Stack-Speicher? Java Basics - Anfänger-Themen 2
izoards Stack... Java Basics - Anfänger-Themen 17
Csircc Rekursive Methode Stack Overflow Java Basics - Anfänger-Themen 10
B Zahlenfolge von Queue in Stack Java Basics - Anfänger-Themen 29
L Stack bilden, push und pop Java Basics - Anfänger-Themen 16
KogoroMori21 Stack und Heap Speicher Java Basics - Anfänger-Themen 1
G Stack und Queue Arbeitsblatt Java Basics - Anfänger-Themen 3
G Stack programmieren Java Basics - Anfänger-Themen 6
Z Datentypen Stack based calculator Java Basics - Anfänger-Themen 8
F speicherort stack oder heap Java Basics - Anfänger-Themen 1
S Rekursiven Stack Java Basics - Anfänger-Themen 6
Curtis_MC Collections Zufälliges Element aus Stack Java Basics - Anfänger-Themen 2
D Queue vs. Stack Java Basics - Anfänger-Themen 6
P Stack, Heap Java Basics - Anfänger-Themen 13
J Stack mit Benutzereingabe Java Basics - Anfänger-Themen 17
J Liste,Queue,Stack sortieren Java Basics - Anfänger-Themen 2
C Stack und Queue in Aktion (Bitte Hilfe für die Klausur) Java Basics - Anfänger-Themen 7
S Sequenz von Zahlen bei einem Stack möglich oder nicht möglich? Java Basics - Anfänger-Themen 5
E Stack vs Queue - Gemeinsamkeiten / Unterschiede Java Basics - Anfänger-Themen 7
C Laufzeit von Stack Operation Java Basics - Anfänger-Themen 5
4 Stack over flow bei rekursiver Tiefensuche Java Basics - Anfänger-Themen 5
J Quicksort mit Stack Java Basics - Anfänger-Themen 4
A Anzahl der Elemente in einem Stack wiedergeben Java Basics - Anfänger-Themen 3
T Stack Overflow - Rekursive Fibonacci Java Basics - Anfänger-Themen 10
K Tiefen- und Breitensuche beim Baum durch Stack und Warteschlange Java Basics - Anfänger-Themen 1
L Liste mittels Stack implementieren Java Basics - Anfänger-Themen 0
A Stack programmieren -> Unklarheiten Java Basics - Anfänger-Themen 1
C Stack - listenbasierte Implementierung Java Basics - Anfänger-Themen 4
L Mit rekursiven Aufrufen einen Stack emulieren Java Basics - Anfänger-Themen 1
T Frage zu Java Stack Java Basics - Anfänger-Themen 5
D Stack-Objekt - LIFO - wait(); notify(); Java Basics - Anfänger-Themen 0
J Array von Objekten, wie schauts im Heap / Stack aus ? Java Basics - Anfänger-Themen 7
M Frage zu Stack und Heap Java Basics - Anfänger-Themen 1
Farbenfroh Suche Übungsaufgaben: BinaryTree, Stack Java Basics - Anfänger-Themen 0
D Aufgabe: Stack mit Iterator Java Basics - Anfänger-Themen 8
X Stack mit Oberklasse, wieso funktioniert es nicht? Java Basics - Anfänger-Themen 8
B Stack/Heap Frage Java Basics - Anfänger-Themen 36
K Probleme mit stack Java Basics - Anfänger-Themen 7
K Wofür wird heute noch die Stack Klasse in Java genutzt Java Basics - Anfänger-Themen 4
F Rekursion Tiefensuch-Problem - Stack Overflow Java Basics - Anfänger-Themen 9
P LinkedList - Stack ... grundlegende Frage Java Basics - Anfänger-Themen 5
B Stack in eine verkettete Liste pushen Java Basics - Anfänger-Themen 4
J OOP Warum braucht man den Stack Java Basics - Anfänger-Themen 3
B Queue mit Daten aus einem Stack füllen Java Basics - Anfänger-Themen 21
G Stack invertieren Java Basics - Anfänger-Themen 3
H Pseudo-Stack (char[] stackArray) mit Zeichen aus einer .txt-Datei befüllen Java Basics - Anfänger-Themen 5
S Stack Problem mit Objekt Java Basics - Anfänger-Themen 2
X String mit String von Objekt im Stack vergleichen? Java Basics - Anfänger-Themen 14
D Stack auslesen mit pop Java Basics - Anfänger-Themen 2
S Stack als verkettete liste/ toString methode Java Basics - Anfänger-Themen 3
S Exceptions bei push/pop in Stack Java Basics - Anfänger-Themen 8
S Eigene Stack Klasse Java Basics - Anfänger-Themen 26
S Stack: Klasseninvariante Java Basics - Anfänger-Themen 4
L OOP Wrapper Klassen - Stack-Aufgabe Java Basics - Anfänger-Themen 2
M Frage zu Stack Java Basics - Anfänger-Themen 3
D Problem mit Set, Stack und Random Java Basics - Anfänger-Themen 2
O Stack Implementierung als verkettete Liste Java Basics - Anfänger-Themen 8
T Probleme bei einen Stack der über drei Dateien funktionieren soll Java Basics - Anfänger-Themen 5
V java.util.Stack Java Basics - Anfänger-Themen 9
K Stack und immer gleiches Objekt Java Basics - Anfänger-Themen 11
kulturfenster Stack / Queue Implementationen Java Basics - Anfänger-Themen 11
S Stack einlesen. Java Basics - Anfänger-Themen 2
E Stack kann nicht implimentiert werden Java Basics - Anfänger-Themen 11
E Eigene Stack Klasse schreiben Java Basics - Anfänger-Themen 12
J Stack Java Basics - Anfänger-Themen 3
K min-int-Wert in'nem Stack Java Basics - Anfänger-Themen 8
L Stack UpnRechner Java Basics - Anfänger-Themen 4
B Stack mit Bildern füllen Java Basics - Anfänger-Themen 2
B Stack mit Strings in zufälliger Reihenfolge füllen Java Basics - Anfänger-Themen 4
J Stack, der Integer-Zahlen enthält Java Basics - Anfänger-Themen 3
K Array Stack Java Basics - Anfänger-Themen 6
O Stack-Klasse Java Basics - Anfänger-Themen 7
S Stack mit Arrays Java Basics - Anfänger-Themen 3
T generischer stack Java Basics - Anfänger-Themen 3
Z Keller/Stack Problem Java Basics - Anfänger-Themen 11
H Stack und Queue Java Basics - Anfänger-Themen 6
M Stack SetValTop Java Basics - Anfänger-Themen 6
G Die Klasse Stack selber schreiben. Java Basics - Anfänger-Themen 2
F Klammertest mit Stack implementieren Java Basics - Anfänger-Themen 5
X Stack Java Basics - Anfänger-Themen 14
J Morgen Java-Klausur. Stack, Heap, Method-Area Java Basics - Anfänger-Themen 2
H Unterschied zwischen Stack und Array Java Basics - Anfänger-Themen 3
F MergeSort iterativ mit Hilfe von Stack Java Basics - Anfänger-Themen 5
S stack Java Basics - Anfänger-Themen 3
S Stack invertieren Java Basics - Anfänger-Themen 14
S Stack-Operationen Java Basics - Anfänger-Themen 59
S Stack.pop() wie genau funktioniert das? Java Basics - Anfänger-Themen 3
A Stack, Frage zur Methode push Java Basics - Anfänger-Themen 4
C Anzahl der Elemente auf einem Stack Java Basics - Anfänger-Themen 4
D Stack chaos Java Basics - Anfänger-Themen 2
megachucky kleines problem mit nem STACK Java Basics - Anfänger-Themen 8
I Stack ist auf einmal empty Java Basics - Anfänger-Themen 3
R Beispiele für Stack & Visualisierung Java Basics - Anfänger-Themen 2
R Stack: Wieso funktioiert das? Java Basics - Anfänger-Themen 2
B eine kleine leichte aufgabe mit einem stack programmieren Java Basics - Anfänger-Themen 2
N Stack-Probleme Java Basics - Anfänger-Themen 2
K Stack Overflow Java Basics - Anfänger-Themen 2
Z Textbasiertes Rollenspiel programmieren! Java Basics - Anfänger-Themen 3

Ähnliche Java Themen

Neue Themen


Oben