# Fehler bei Krümel&Monster



## 12345j51 (15. Mrz 2012)

Hallo zusammen,

ich programmiere im Moment das Spiel "Krümel&Monster", eine Art Pacman, nach einer bestimmten Anleitung, die, wenns wen interessiert, unter Krümel und Monster zu finden ist.

Jetzt habe ich ein Problem, bei dem auch die Anleitung nicht weiterhilft. Ich will einen boolean-Methodenwert von einer Klasse in eine andere übergeben, scheitere aber immer wieder:

Das ist die Klasse, die übergibt:


```
public class ZELLE
{
    int positionX;
    int positionY;
    boolean istMauer;
    //Referenzattribut
    ZELLENSYMBOL zSymbol;
    
    //Konstruktor
    public ZELLE(int xNeu, int yNeu)
    {
        positionX = xNeu;
        positionY = yNeu;
        istMauer =false;
        
        zSymbol = new ZELLENSYMBOL(positionX, positionY);
        zSymbol.FuellFarbeSetzen("blau");
        zSymbol.FuellungSichtbarSetzen(false);
    }
    
    //Methoden
    void istMauerSetzen(boolean istMauerNeu)
    {
        
        istMauer = istMauerNeu;
        
        if(istMauer==true)
        {
            zSymbol.FuellungSichtbarSetzen(true);
        }
        else
        {
            zSymbol.FuellungSichtbarSetzen(false);
        }
    }
    
   boolean IstMauerGeben()
   {
      
      if(istMauer==true)
      {
         return int positionX;
         return int positionY;
  
      }
      else
      {
          return false;
      }    
    
    
    }
}
```

diese Klasse soll den Ausgabewert der Methode IstMauerGeben, sprich die Koordinaten der Mauer folgender Klasse übergeben:


```
public class LABYRINTH
{
   //Attribute
   int breite;
   int hoehe;
   //Referenzattribute
   ZELLE[][]spielFlaeche;
   
    /**
     * Konstruktor für Objekte der Klasse LABYRINTH
     */
    public LABYRINTH(int breiteNeu, int hoeheNeu)
    {
        breite= breiteNeu;
        hoehe = hoeheNeu;
        spielFlaeche = new ZELLE[breite][hoehe];
                
        
        for(int zaehlerX =0; zaehlerX <breite-1; zaehlerX++)
       {
            
            for(int zaehlerY=0;zaehlerY<hoehe-1;zaehlerY++){
                
                spielFlaeche[zaehlerX][zaehlerY]=new ZELLE(zaehlerX, zaehlerY);
                }
            }
        }
    void  GaengeErstellen(){
        spielFlaeche[1][1].istMauerSetzen(true);
        spielFlaeche[1][2].istMauerSetzen(true);
        spielFlaeche[1][3].istMauerSetzen(true);
        spielFlaeche[2][3].istMauerSetzen(true);
        spielFlaeche[2][4].istMauerSetzen(true);
        spielFlaeche[7][1].istMauerSetzen(true);
        spielFlaeche[6][1].istMauerSetzen(true);
        spielFlaeche[6][2].istMauerSetzen(true);
        spielFlaeche[6][3].istMauerSetzen(true);
        spielFlaeche[7][3].istMauerSetzen(true);
        spielFlaeche[7][4].istMauerSetzen(true);
        spielFlaeche[7][5].istMauerSetzen(true);
        spielFlaeche[6][5].istMauerSetzen(true);
        
    }
    
    int BreiteGeben(){
        return breite;
    }
    
    int HoeheGeben(){
        return hoehe;
    }
     
    boolean IstMauerAufZelle(int positionX, int positionY)
    {
         IstMauerGeben();
       
       if(IstMauerGeben()==true)
       {
           return true;
          
       }
       else
       {
           return false;
       }
     
    }   
    }
```

das funktioniert aber nicht ganz. Der (boolean)Wert der Methode IstMauerAufZelle soll dann wiederum weitergegeben werden, aber ab da stimmt dann alles.

Vermutlich ist es ein recht simpler Fehler, aber ich bin Anfänger und kenn mich noch wenig aus. Ich bitte deshalb um Nachsicht  

Gruß und danke im Voraus

12345j51


----------



## 12345j51 (15. Mrz 2012)

achja, bevor ichs vergesse: DAS IST KEINE HAUSAUFGABE! 

Ich mache das freiwillig, um mir evtl. mit einem Referat eine gute Note zu verdienen, nicht, weil ich muss!


----------



## Quaxli (15. Mrz 2012)

Das Problem ist die Methoden-Definition:


```
boolean IstMauerGeben(){
      
      if(istMauer==true){
         return int positionX;
         return int positionY;
      } else{
         return false;
      }    
  }
```

Lt. Definition soll die Methode einen boolean zurück geben. Wenn aber istMauer ture ist und die if-Bedingung greift, wird versucht einen int zurück zugeben.
Das kollidiert mit der Definition des Rückgabewertes im Methodenkopf.

Und zwei return-Anweisungen hintereinander funktionieren gleich gar nicht...


----------



## TimoH. (15. Mrz 2012)

In der Methode 
	
	
	
	





```
istMauerGeben
```
 hast du folgendes:


```
boolean IstMauerGeben()
   {
      
      if(istMauer==true)
      {
         return int positionX;
         return int positionY;
  
      }
      else
      {
          return false;
      }    
    
    
    }
```

dies ist so nicht machbar, da die Methode ja einen boolean-wert als Rückgabe erwartet -> return int ... ist injedem Fall falsch und wird einen Fehler geben, hinzu kommt das 2. return eine Zeile darunter, das würde nie erreich werden.

Du solltest wohl eher sowas wie:

```
boolean IstMauerGeben(){
     if(istMauer == true){
        return true;
     }else{
        return false;
     }
}
```
Du kannst es natürlich noch kürzer machen indem du einfach istMauer zurück gibst,

```
boolean IstMauerGeben(){
     return istMauer;
}
```

Es scheint so als würden dir grundlegende Java-Kenntnisse fehlen.

Das zweite Problem:

```
boolean IstMauerAufZelle(int positionX, int positionY)
    {
         IstMauerGeben();
       
       if(IstMauerGeben()==true)
       {
           return true;
          
       }
       else
       {
           return false;
       }
     
    }
```

Du willst ja über die Koordinaten eine bestimmte Zelle abfragen, hier hast du dein zweidimensionalles array spielfläche.
Also kannst du z.B. folgendes machen


```
boolean IstMauerAufZelle(int positionX, int positionY)
    {
         return spielFlaeche[positionX][positionY].IstMauerGeben();
    }
```

Das gibt dir true zurück, wenn an diesen Koordinaten eine Mauer ist.

Mein Tipp:
Arbeite dich ersteinmal in Grundlegende Sachen rein und dann setze das hier fort


----------



## 12345j51 (15. Mrz 2012)

So, damit wäre das kurz und schmerzlos geklärt!

Ich danke herzlich für die wirklich schnelle Hilfe und wünsche noch einen schönen Nachmittag!


----------



## 12345j51 (20. Mrz 2012)

Auf der Zielgeraden hakts nochmal...

zum Schluss ist eine Methode namens (boolean) MonsterMampfiBegegnungTesten() vorgesehen, die ausgeben soll, ob Mampfi und Monster sich auf einem Feld begegnen. 


```
boolean MonsterMampfiBegegnungTesten(int monsterNr)
    {
        if((mampfi.PositionXGeben()==monsterliste[monsterNr].PositionXGeben()==true) && 
           (mampfi.PositionYGeben()==monsterliste[monsterNr].PositionYGeben()==true))
        {
            return true;
        }
        else
        {
            return false;
        }
        
    }
```

Sie ist in der Klasse SPIELSTEUERUNG eingefügt, die als Spielleiter fungiert, und beinhaltet eine Referenz auf die Klasse MAMPFI und die Klasse MONSTER, die der Superclass SPIELFIGUR untergeordnet sind. In diese Superclass ist eine Methode PositionXGeben() und eine  PositionYGeben()
eingefügt, die für beide Klassen gilt:


```
int PositionXGeben()
    {
        return positionX;
    }
```

bzw 


```
int PositionYGeben()
    {
        return positionY;
    }
```


monsterliste ist ein Array der Klasse Monster, ebenfalls in SPIELSTEUERUNG eingefügt:


```
MONSTER[] monsterliste;
    
         ....

        monsterliste = new MONSTER[5];
        monsterliste[1] = new MONSTER(aktlabyrinth, "gelb", 2, 2);
        monsterliste[2] = new MONSTER(aktlabyrinth, "blau", 3, 3);
        monsterliste[3] = new MONSTER(aktlabyrinth, "rot", 4, 4);
        monsterliste[4] = new MONSTER(aktlabyrinth, "weiss", 6, 6);
```

ich glaube, hier liegt der Fehler irgendwo, auf alle Fälle erhalte ich bei Aufruf der Methode MonsterMampfiBegegnungTesten() nie den Wert true, auch wenn die Positionen identisch sind.
Ich hoffe, jemand kann mir ein allerletztes Mal helfen.

Vielen herzlichen Dank im voraus!

12345j51


----------



## TimoH. (20. Mrz 2012)

wo rufst du denn die MonsterMampfiBegegnungTesten Methode auf?


----------



## 12345j51 (20. Mrz 2012)

oh, da kam der Quelltext dazwischen 

in der Klasse SPIELSTEUERUNG.


----------



## TimoH. (20. Mrz 2012)

ein codeausschnitt von der konkretenstelle des aufrufs wäre nett


----------



## 12345j51 (20. Mrz 2012)

Hier auch das Umfeld, die Methode steht allein schon oben:


```
/**
 * Die Klasse SPIELSTEUERUNG veranschaulicht Informationen zum Spiel und sorgt für einfache
 * Steuerung
 * 
 * 
 * 
 * @version 18.03.2012
 */
import java.util.Random;

public class SPIELSTEUERUNG
{
   //Attribute
   /**
    * Zeigt den aktuellen Punktestand des Spielers
    */
   int punkteStand;
   /**
    * zeigt das aktuelle Level
    */
   int level;
   /**
    * zeigt die Leben, die aktuell zur Verfügung stehen
    */
   int leben;
   int PunktewertNormalerKrümel;
   int PunktewertPowerkrümel;
   private int timer1;
   /**
    * Die Referenzattribute der Klassen LABYRINTH ,MAMPFI und STEUERUNGSANZEIGE
    */
   LABYRINTH aktlabyrinth;
   MAMPFI mampfi;
   STEUERUNGSANZEIGE anzeige;
   MONSTER[] monsterliste;
   private Random zufallszahlGenerator;
   
   SPIELSTEUERUNG()
   {
        punkteStand = 0;
        level = 10;
        leben = 3;
        aktlabyrinth = new LABYRINTH();
        mampfi = new MAMPFI(aktlabyrinth);
        anzeige = new STEUERUNGSANZEIGE();
        anzeige.Anmelden(this);
        anzeige.punkteStand = 0;
        anzeige.anzahlLeben = 3;
        anzeige.levelNummer = 1;
        anzeige.SchriftFarbeSetzen("gelb");
        anzeige.HintergrundFarbeSetzen("blau");
        aktlabyrinth.MampfiStartXGeben();
        aktlabyrinth.MampfiStartYGeben();
        PunktewertNormalerKrümel = 10;
        PunktewertPowerkrümel = 30;
        zufallszahlGenerator = new Random();
        monsterliste = new MONSTER[5];
        monsterliste[1] = new MONSTER(aktlabyrinth, "gelb", 2, 2);
        monsterliste[2] = new MONSTER(aktlabyrinth, "blau", 3, 3);
        monsterliste[3] = new MONSTER(aktlabyrinth, "rot", 4, 4);
        monsterliste[4] = new MONSTER(aktlabyrinth, "weiss", 6, 6);

    }
    
    void AufTasteReagieren(int taste)
    {
        switch(taste)
        {
            case 37: //Taste "links"
            mampfi.NachWestenBlicken();
            break;
            
            case 38: //Taste "oben"
            mampfi.NachNordenBlicken();
            break;
            
            case 39: //Taste "rechts"
            mampfi.NachOstenBlicken();
            break;
            
            case 40: //Taste "unten"
            mampfi.NachSuedenBlicken();
            break;
            
            case 83: //Taste 'S'
            anzeige.TickerStarten(1000);
            break;
            
            case 80: //Taste P
            anzeige.TickerAnhalten();
            break;
        }
        
    }    
            
     public void SpielzugAuswerten()
     {
        int positionX;
        int positionY;
        positionX = mampfi.PositionXGeben();
        positionY = mampfi.PositionYGeben();
        
        switch(aktlabyrinth.KruemelBelegungAnzeigen(positionX,positionY))
        {
            case 'L': //wenn kein Krümel
            break;
            
            case 'N': //wenn normaler Krümel
            aktlabyrinth.KruemelEntfernen(positionX,positionY);
            anzeige.PunkteStandSetzen(anzeige.punkteStand + PunktewertNormalerKrümel);
            break;
            
            case 'P': //wenn Powerkrümel
            aktlabyrinth.KruemelEntfernen(positionX,positionY);
            anzeige.PunkteStandSetzen(PunktewertPowerkrümel+anzeige.punkteStand);
            timer1 = 30;
            break;
        }  
      
    }        
         
   void Tick()
   {
       
       switch(mampfi.blickrichtungGeben())
       {
       case 'N':
       
       mampfi.NachNordenGehen();
       mampfi.NachNordenBlicken();
       SpielzugAuswerten();
       break;
       
       case 'W':
       mampfi.NachWestenGehen();
       mampfi.NachWestenBlicken();
       SpielzugAuswerten();
       break;
       
       case 'O':
       mampfi.NachOstenGehen();
       mampfi.NachOstenBlicken();
       SpielzugAuswerten();
       break;
       
       case 'S':
       mampfi.NachSuedenGehen();
       mampfi.NachSuedenBlicken();
       SpielzugAuswerten();
       break;
       }  
     for(int zaehler=0; zaehler<=3; zaehler = zaehler+1)
       {
     switch(zufallszahlGenerator.nextInt(7))
       {
         case 0://wenn Zufallszahl die 0 ist
         monsterliste[zaehler].NachOstenGehen();
         break;
         
         case 1: //wenn Zufallszahl die 1 ist
         monsterliste[zaehler].NachSuedenGehen();
         break;
         
         case 2: //wenn Zufallszahl die 2 ist
         monsterliste[zaehler].NachWestenGehen();
         break;
         
         case 3: //wenn Zufallszahl die 3 ist
         monsterliste[zaehler].NachNordenGehen();
         break;
         
         case 4: //wenn Zufallszahl 4 ist
         switch (monsterliste[zaehler].blickrichtungGeben())
         {
             case 'O'://wenn Blickrichtung Osten
             monsterliste[zaehler].NachOstenGehen();
             break;
             
             case 'S'://wenn Blickrichtung Süden
             monsterliste[zaehler].NachSuedenGehen();
             break;
             
             case 'W'://wenn Blickrichtung Westen
             monsterliste[zaehler].NachWestenGehen();
             break;
             
             case 'N'://wenn Blickrichtung Norden
             monsterliste[zaehler].NachNordenGehen();
             break;
          }    
          }
       
       
       if(timer1>0)
       {
           timer1 = timer1 - 1;
           if(timer1 ==0)
           {
               monsterliste[zaehler].VerwundbarSetzen(false);
           }
           else
           {
               monsterliste[zaehler].VerwundbarSetzen(true);
           }     
       }       
        }   
    }   
    
    boolean MonsterMampfiBegegnungTesten(int monsterNr)
    {
        if((mampfi.PositionXGeben()==monsterliste[monsterNr].PositionXGeben()==true) && 
           (mampfi.PositionYGeben()==monsterliste[monsterNr].PositionYGeben()==true))
        {
            return true;
        }
        else
        {
            return false;
        }
        
    }
    
}
```

Das ist jetz zwar ein bisschen viel, aber das ist die ganze Klasse SPIELSTEUERUN, nur zur Sicherheit


----------



## TimoH. (20. Mrz 2012)

hm ich sehe zwar immernoch nicht wo du MonsterMampfiBegegnungTesten genau aufrufst, du solltest eventuell bei der auswertung des zuges die monsterliste durchlaufen und gucken ob monster i mit mampfi auf dem gleichen feld ist, das natürlich dann mit deiner MonsterMampfiBegegnungTesten methode


----------



## 12345j51 (20. Mrz 2012)

Zeile 209-223 steht die Methode...

Aufrufen tu ich sie natürlich nur am Objekt, is ja BlueJ...


----------



## TimoH. (20. Mrz 2012)

es kann sein, dass wir aneinander vorbeireden , soweit ich das verstanden habe willst du ja testen ob mampfi auf ein monster trifft, das würde ich ungefähr so lösen

Die Schleife am Ende der Methode

```
public void SpielzugAuswerten()
     {
        int positionX;
        int positionY;
        positionX = mampfi.PositionXGeben();
        positionY = mampfi.PositionYGeben();
        
        switch(aktlabyrinth.KruemelBelegungAnzeigen(positionX,positionY))
        {
            case 'L': //wenn kein Krümel
            break;
            
            case 'N': //wenn normaler Krümel
            aktlabyrinth.KruemelEntfernen(positionX,positionY);
            anzeige.PunkteStandSetzen(anzeige.punkteStand + PunktewertNormalerKrümel);
            break;
            
            case 'P': //wenn Powerkrümel
            aktlabyrinth.KruemelEntfernen(positionX,positionY);
            anzeige.PunkteStandSetzen(PunktewertPowerkrümel+anzeige.punkteStand);
            timer1 = 30;
            break;
        }  
        for(int i = 0; i < monsterliste.length;i++){
             if(MonsterMampfiBegegnungTesten(i)){
                //Mache irgendwas beim aufeinandertreffen
             }
        }
    }
```

vielleicht meinst du ja auch was anderes.


----------



## 12345j51 (20. Mrz 2012)

ich glaube, wir haben wirklich aneinander vorbeigeredet 

Die Beschreibung der Methode gibt es ja eigentlich recht eindeutig in der Anleitung, nach der ich programmiere. 

So ab Seite 5 stehts: http://www.kruemelundmonster.de/unterrichtskonzept/Kap19.pdf


----------



## 12345j51 (20. Mrz 2012)

wenn es interessiert, hier noch mal der Stand bi sjetzt, kurz vor Schluss:

File-Upload.net - Kr-mel-und-Monster.zip


----------



## TimoH. (20. Mrz 2012)

wie ich gerade lese , ist genau das was ich geschrieben habe die lösung... du solltest die methode speilzugauswerten erweitern mit dem was ich da eingefügt hab, deine methode scheint richtig zu sein


----------



## 12345j51 (20. Mrz 2012)

dann herzlichen Dank für die schnelle Hilfe!


----------

