Erste Schritte Stack im Rollenspiel

Diskutiere Stack im Rollenspiel im Java Basics - Anfänger-Themen Forum; Hallo, Wie schreibe ich die Methode raumZurueck2() ? Wie kommen die Räume, die man nacheinander betritt, in den Stack hinein? Das ist das...

  1. Devanther
    Devanther Mitglied
    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 (Text):
    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 (Text):
    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 (Text):
    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: 20. Dez. 2018
  2. Vielleicht hilft dir dieses Buch hier weiter.
  3. mihe7
    mihe7 Bekanntes Mitglied
    Irgendwie verstehe ich das Problem nicht ganz. Im Endeffekt hast Du z. B. folgendes Schema:
    Code (Java):

    Stack<Raum> weg = new Stack<>();

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

    public void zurueck() {
        aktuellerRaum = weg.pop();
    }
     
     
  4. Devanther
    Devanther Mitglied
    wenn ich das so eingebe, bekomm ich die ganzen Fehlermeldungen nicht weg,
    aktueller Raum und naechster Raum erscheinen rot..!

    Code (Text):
    public void raumZurueck3() {
        stackOfRooms.push(aktuellerRaum);
        aktuellerRaum = naechsterRaum;
        aktuellerRaum = stackOfRooms.pop();
       
        System.out.println("Current Stack : " + stackOfRooms);
     
        }
     
    Zuletzt bearbeitet: 20. Dez. 2018
  5. Devanther
    Devanther Mitglied
    edit: Ich schaff es nur einen, nicht mehrere Räume zurückzugehen -.-
     
    Zuletzt bearbeitet: 20. Dez. 2018
  6. mihe7
    mihe7 Bekanntes Mitglied
    Du sollst das auch nicht so eingeben. Damit sollte lediglich angedeutet werden:
    1. Du nimmst einen Stack, der Raum-Objekte (und nicht wie bei Dir Strings) verwaltet.
    2. Immer, wenn Du einen Raum verlässt, legst Du ihn auf den Stack.
    3. Immer, wenn Du zurück willst, nimmst Du den Raum vom Stack.
     
  7. Devanther
    Devanther Mitglied
    Hab ich.
    Ich schaff es alleine nicht...
    Kann mir jemand schreiben, wie die Methode dann richtig aussieht?

    Ich kann Schritt 2 und 3 nicht in Code umwandeln!
     
  8. Meniskusschaden
    Meniskusschaden Bekanntes Mitglied
    Dann solltest du den neuen Code mal posten. Bisher hattest du den Stack immer für Strings deklariert.
     
  9. Devanther
    Devanther Mitglied
    Code (Text):
    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.
     
  10. Meniskusschaden
    Meniskusschaden Bekanntes Mitglied
    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
    war bestimmt nicht das "Verlassen" beim zurück gehen gemeint, sondern beim vorwärts gehen.
     
  11. mihe7
    mihe7 Bekanntes Mitglied
    So ist es.

    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}
     
  12. Wenn du Java lernen möchtest, empfehlen wir dir dieses Buch hier
Passende Stellenanzeigen aus deiner Region:





Die Seite wird geladen...

Stack im Rollenspiel - Ähnliche Themen

Stack mit Benutzereingabe
Stack mit Benutzereingabe im Forum Java Basics - Anfänger-Themen
Liste,Queue,Stack sortieren
Liste,Queue,Stack sortieren im Forum Java Basics - Anfänger-Themen
FXML: StackPane als Root-Element
FXML: StackPane als Root-Element im Forum AWT, Swing, JavaFX & SWT
MergeSort iterativ mit Stacks
MergeSort iterativ mit Stacks im Forum Java Basics - Anfänger-Themen
Stacks und Queues Implementieren
Stacks und Queues Implementieren im Forum Java Basics - Anfänger-Themen
Thema: Stack im Rollenspiel