Erzeugung unterschiedlicher Speicheradressen

hopperjoe

Neues Mitglied
Hallo zusammen ,
ich sitze momentan an einer Praktikumsaufgabe fürs Studium.
Wir sollen das Text basierte Beispiel Programm "Die Welt von Zuul" verändern und zusätzliche Funktionen einbauen.
Wir haben das Spiel unbenannt und es "Homer hat gesoffen" genannt. Ziel des Spiels den Schlüssel von Homers Auto in Springfield zu suchen...
Das Problem das wir jetzt haben ist, das unser Spiel nicht beendet wird wenn wir genau am Selben Ort sind wo der Schlüssel ist,der (durch die Funktion Random) zufällig versteckt wurde.
[Java]
if(aktuellerRaum.equals(zufallsraum))
{
System.out.println("Sie haben den Schlüssel gefunden!!");
beendet = true;
}
[/Java]

Wenn wir die Speicheradressen ausgeben lassen , kommen von "zufallsraum" und aktuellerRaum" auch unterschiedliche Adresse raus. Das liegt meiner Meinung nach das wir einmal eine ArrayList doppelt erstellen....

Kann uns da einer eventuell ein Typ geben für Anfänger?


Java:
 import java.util.*;


/**
 *  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 ArrayList<Raum> raumliste;
    private Random zufallsgenerator;
    Charakter charakter;
    
        
    /**
     * 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 ArrayList raeumeAnlegen()
    
    {
        Raum draussen, grundschule, supermarkt, kneipe, akw, burger;
        this.raumliste = new ArrayList<Raum>();
       
        
      
        // die Räume erzeugen
        draussen = new Raum("Auf der Evergreenterrace");
        grundschule = new Raum("bei der Springfielder Grundschule");
        supermarkt = new Raum("bei Apu im Kwiki Markt");
        kneipe = new Raum("in Moe´s Bar");
        akw = new Raum("im Atomkraftwerkk");
        burger= new Raum("bei Krusty Burger");
        // die Ausgänge initialisieren
        draussen.setzeAusgang("east", grundschule);
        draussen.setzeAusgang("south", kneipe);
        draussen.setzeAusgang("west", supermarkt);


        grundschule.setzeAusgang("north", draussen);
        grundschule.setzeAusgang("south", akw);
        grundschule.setzeAusgang("west", kneipe);


        supermarkt.setzeAusgang("north", draussen);
        supermarkt.setzeAusgang("east", kneipe);
        supermarkt.setzeAusgang("south", burger);


        kneipe.setzeAusgang("north", draussen);
        kneipe.setzeAusgang("south", akw);
        kneipe.setzeAusgang("west", supermarkt);
        kneipe.setzeAusgang("east", grundschule);
        kneipe.setzeAusgang("westsouth", burger);
        
        
        akw.setzeAusgang("north", kneipe);
        akw.setzeAusgang("west", burger);
        akw.setzeAusgang("east", grundschule);
        
        burger.setzeAusgang("north",supermarkt);
        burger.setzeAusgang("east",akw);
        burger.setzeAusgang("northeast",kneipe);
        




        aktuellerRaum = draussen;  // das Spiel startet draussen
        this.raumliste.add(draussen);
        this.raumliste.add(kneipe);
        this.raumliste.add(grundschule);
        this.raumliste.add(burger);
        this.raumliste.add(supermarkt);
        this.raumliste.add (akw);
        
        return this.raumliste;
        
    }
   /**
     * Wähle zufällig eine der Standardantworten aus.
     * @return eine zufällig gewählte Standardantwort.
     */
    private Raum raumAuswaehlen(ArrayList raumliste)
    {
        // Erzeuge eine Zufallszahl, die als Index in der Liste der
        // Standardantworten benutzt werden kann. Die Zahl wird im Bereich
        // von null (inklusiv) bis zur Größe der Liste (exklusiv) liegen.
        zufallsgenerator = new Random();
        Raum zufallsraum = null;
       
        do{
            int index = zufallsgenerator.nextInt(raumliste.size()); 
            zufallsraum = (Raum) raumliste.get(index);
        }
        while(zufallsraum == (Raum) raumliste.get(0));
        //System.out.println(zufallsraum.gibKurzbeschreibung()+"llllll");
        return  zufallsraum;
    }
    
    private Raum istImRaum(ArrayList raumliste, Raum zufallsraum)
    {
        Random random = new Random();
        Raum charakterRaum =null;
        
        do{
            int  index1 = random.nextInt(raumliste.size()); 
            charakterRaum = (Raum) raumliste.get(index1);
            
          
        }
        while(charakterRaum == (Raum) raumliste.get(0)||charakterRaum.equals(zufallsraum));
        //System.out.println(charakterRaum.gibKurzbeschreibung()+"CCCCCCC");
        return charakterRaum;
    }


    /**
     * Die Hauptmethode zum Spielen. Läuft bis zum Ende des Spiels
     * in einer Schleife.
     */
    public void spielen() 
    {            
        willkommenstextAusgeben();
        
        Raum zufallsraum   =  raumAuswaehlen(raeumeAnlegen());
        Raum charakterRaum =  istImRaum(raeumeAnlegen(), zufallsraum);
        Charakter charakter = new Charakter(" Barney ", "der Trunkenbold aus Springfield ");


        // Die Hauptschleife. Hier lesen wir wiederholt Befehle ein
        // und führen sie aus, bis das Spiel beendet wird.
                
        boolean beendet = false;
        boolean test = false;
        while (! beendet) {
            Befehl befehl = parser.liefereBefehl();
            test = verarbeiteBefehl(befehl);
            System.out.println(zufallsraum+"        zufallsraum");
            System.out.println(aktuellerRaum+"     aktuellerraum");
            System.out.println(charakterRaum+"    charakterraum");
             
           //System.out.println("wihle funktion"+zufallsraum.gibKurzbeschreibung());
          if(test == true )
          {
              beendet = true;
          }
           
          if(aktuellerRaum.equals(zufallsraum))
          {
                        System.out.println("Sie haben den Schlüssel gefunden!!");
                        beendet = true;
          }         
              
              //System.out.println(charakterRaum.gibKurzbeschreibung());
          if(aktuellerRaum.equals(charakterRaum))
          {
               System.out.println("Sie haben " + Charakter.gibName()+ "gefunden");
               System.out.println(Charakter.gibBeschreibung());//
               System.out.println("Der Schlüssel ist " +zufallsraum.gibKurzbeschreibung());
          }
           
           
           
        }
        System.out.println("Danke für dieses Spiel. Auf Wiedersehen.");
    
    }
    /**
     * Einen Begrüßungstext für den Spieler ausgeben.
     */
    private void willkommenstextAusgeben()
    {
        System.out.println();
        System.out.println("Willkommen zum Spiel,");
        System.out.println("Homer hat gesoffen!");
        System.out.println("Spielanweisung :");
        System.out.println("Homer Simpson wacht eines Morgens verkatert auf ");
        System.out.println("der Evergreen Terrace auf, da vermutlich das letzte Bier schlecht war......");
        System.out.println("Plötzlich wird ihm klar, dass er Marge vom Flughafen"); 
        System.out.println("abholen soll.Nur das Problem ist , wo ist der Autoschlüssel??");
        System.out.println("Der Spieler versucht Homer durch Springfield zu ");
        System.out.println("navigieren um in einer Minute den Schlüssel wieder zu 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")) {
            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 in Springfield 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.
        }
    }
}
 

InfectedBytes

Top Contributor
Java:
Raum zufallsraum   =  raumAuswaehlen(raeumeAnlegen());
Raum charakterRaum =  istImRaum(raeumeAnlegen(), zufallsraum);

Hier liegt dein Problem, du legst neue Räume an und wählst einen Raum zufällig.
Dann erstellst du aber nochmal neue Räume und wählst davon einen für den Charakter aus.
Lösung:
Java:
raeumeAnlegen();
Raum zufallsraum   =  raumAuswaehlen(this.raumliste);
Raum charakterRaum =  istImRaum(this.raumliste, zufallsraum);

Ansonsten hast du einiges komplizierter gemacht als nötig^^
z.b. deine zufallsauswahl für den Raum:
Java:
private Raum raumAuswaehlen(ArrayList raumliste)
    {
        // Erzeuge eine Zufallszahl, die als Index in der Liste der
        // Standardantworten benutzt werden kann. Die Zahl wird im Bereich
        // von null (inklusiv) bis zur Größe der Liste (exklusiv) liegen.
        zufallsgenerator = new Random();
        Raum zufallsraum = null;
 
        do{
            int index = zufallsgenerator.nextInt(raumliste.size()); 
            zufallsraum = (Raum) raumliste.get(index);
        }
        while(zufallsraum == (Raum) raumliste.get(0));
        //System.out.println(zufallsraum.gibKurzbeschreibung()+"llllll");
        return  zufallsraum;
    }
Erstmal erzeugst du jedes mal ein neues Random Objekt. Da dieses aber auch an anderen Stellen benötigt wird, wäre es einfacher dieses einmal direkt bei der deklaration der Variable zu erzeugen:
Java:
class Spiel {
    private Random zufallsgenerator = new Random();
    ....
}
Dann nutzt du eine Schleife um sicherzustellen, das nicht der erste Raum verwendet wird, du kannst aber einfach dem Zufallsgenerator sagen, dass er nicht Zahlen von 0-size erzeugt, sondern nur von 1-size:
Java:
private Raum raumAuswaehlen(ArrayList raumliste) {
  int index = zufallsgenerator.nextInt(1, raumliste.size());//wird niemals 0 sein
  return raumliste.get(index);
}

Und was soll diese MEthode?
Java:
    private Raum istImRaum(ArrayList raumliste, Raum zufallsraum)
    {
        Random random = new Random();
        Raum charakterRaum =null;
 
        do{
            int  index1 = random.nextInt(raumliste.size()); 
            charakterRaum = (Raum) raumliste.get(index1);
 
 
        }
        while(charakterRaum == (Raum) raumliste.get(0)||charakterRaum.equals(zufallsraum));
        //System.out.println(charakterRaum.gibKurzbeschreibung()+"CCCCCCC");
        return charakterRaum;
    }
Ich dachte der Startraum soll fest sein? Aber hier wird der charakter dann doch wieder zufällig verteilt.

edit: sorry, ich dachte dein charakterRaum soll gleich dem startraum sein, hab mich nur verlesen^^
Aber auch hier kannst du die Schleife ein wenig vereinfachen, indem du z.b. die zufallszahl wie oben erzeugst, wodurch du nur noch prüfen musst, dass der raum nicht der zufallsraum ist.
 
Zuletzt bearbeitet:

Neue Themen


Oben