# Spinnenwelt Greenfoot anzahlHindernisse



## CT (3. Dez 2010)

Hallo,
Ich habe als Hausaufgabe aufbekommen, die Methode anzahlHindernisse zu schreiben, mit der eine Spinne rechts an einer Reihe Hindernissen vorbeiläuft und die Anzahl der Hindernisse mitzählt. Nach dem Ende der Reihe soll die Anzahl der Hindernisse ausgegeben werden. Die Spinne soll auch weiterlaufen, wenn rechts von ihr kein Hindernis ist. Dann darf dort natürlich nicht mitgezählt werden.
Hier der Quelltext der Spinne:

```
import greenfoot.*;  // (World, Actor, GreenfootImage, and Greenfoot)
import java.util.List;
import javax.swing.JOptionPane;

/**
 * Klasse für Objekte vom Typ Spinne.
 * @author Mathias Müller, verändert von René Vorwerk
 * @version 29.08.2006, 24.09.2010
 */
public class Spinne extends Actor
{

    private int fliegen;
    private boolean nachrichten;
    public boolean geklatscht;
    public int hindernisse;
    
    /**
     * Erzeugt ein Spinne-Objekt.
     */
    public Spinne()
    {
        fliegen = 0;
        nachrichten = true;
        geklatscht = false;
    }
    
    /**
     * Erzeugt ein Spinne-Objekt mit einer gegebenen Anzahl Fliegen.
     * @param fliegen die Anzahl der gefressenen Fliegen
     */
    public Spinne(int fliegen)
    {
        if(fliegen < 0) {
            fliegen = 0;
        }
        this.fliegen = fliegen;
        nachrichten = true;
        geklatscht = false;
    }
    
    /**
     * Die Spinne dreht sich um 90° entgegen dem Uhrzeigersinn. Wirkungslos bei geklatschter Spinne.
     */
    public void linksDrehen() {
        if(!geklatscht) {
            setRotation((getRotation()+270) % 360);
        }
    }
    
    /**
     * Die Spinne dreht sich um 90° im Uhrzeigersinn. Wirkungslos bei geklatschter Spinne.
     */
    public void rechtsDrehen() {
        if(!geklatscht) {
            setRotation((getRotation()+90) % 360);
        }
    }
    
    /**
     * Die Spinne geht einen Schritt in Blickrichtung, wenn sie nicht vor einem Hindernis steht. Wirkungslos bei geklatschter Spinne.
     * Läuuft sie dabei auf eine Klatsche, wird sie geklatscht.
     */
    public void schritt() {
        if(!geklatscht) {
            boolean kv = klatscheVorn();
            int richtung = getRotation();
            int x = 0;
            int y = 0;
            switch(richtung) {
                case 0:
                    x = getX() + 1;
                    y = getY();
                    break;
                case 90:
                    x = getX();
                    y = getY()+1;
                    break;
                case 180:
                    x = getX()-1;
                    y = getY();
                    break;
                case 270:
                    x = getX();
                    y = getY()-1;
                    break;
            }
      
            if(!hindernisVorn()) {
                setLocation(x,y);
                 Greenfoot.delay(1);
                if(kv) {
                    geklatscht = true;
                    setImage("images/thekla_geklatscht.png");
                    if(nachrichten) {
                        System.out.println("Die Spinne wurde geklatscht. Fehler.");
                    }
                }
                
            }
            else {
                if(nachrichten) {
                    System.out.println("Vor der Spinne liegt ein Hindernis.");
                }
            }
        }
    }
    
    /**
     * Die Spinne frisst eine Fliege, falls mindestens eine auf dem Platz liegt. Wirkungslos bei geklatschter Spinne.
     */
    public void fliegeFressen() {
        if(!geklatscht) {
            
            Actor fliege = getOneObjectAtOffset(0,0,Fliege.class);
            if(fliege != null) {
                fliegen++;
                getWorld().removeObject(fliege);
                
            }
            else {
                if(nachrichten) {
                    System.out.println("Auf dem Platz liegt keine Fliege. Fehler.");
                }
            }
        }
    }
    
    /**
     * Die Spinne wird mit Anzahl zusätzlichen Fliegen gefüttert. Wirkungslos bei geklatschter Spinne.
     */
    public void fliegenFuettern(int anzahl) {
        if(!geklatscht) {
            fliegen +=anzahl;
        }
    }
    
    /**
     * Die Spinne spuckt eine Fliege aus, falls sie mindestens eine gefressen hat. Wirkungslos bei geklatschter Spinne.
     */
    public void fliegeAusspucken() {
        if(!geklatscht) {
            
            if(fliegen>0) {
                getWorld().addObject(new Fliege(),getX(),getY());
                setLocation(getX(),getY());
                fliegen--;
                
            }
            else {
                if(nachrichten) {
                    System.out.println("Die Spinne hat keine Fliege gefressen. Fehler.");
                }
            }
        }
    }
        
    /**
     * Prüft, ob auf dem Platz vor der Spinne eine Klatsche lauert. 
     * @return true: Klatsche, false: keine Klatsche, bei geklatschter Spinne: immer false
     */
    public boolean klatscheVorn() {
        if(!geklatscht) {
            int dx = 0;
            int dy = 0;
            int richtung = getRotation();
            switch(richtung) {
                case 0:
                    dx = 1; break;
                case 90:
                    dy = 1; break;
                case 180:
                    dx = -1; break;
                case 270:
                    dy = -1; break;
            }
            Actor klatsche = getOneObjectAtOffset(dx,dy,Klatsche.class);
            return klatsche != null;
        }
        else {
            return false;
        }
    }
    
    /**
     * Prüft, ob auf dem Platz vor der Spinne ein Hindernis liegt.
     * @return true: Hindernis, false: kein Hindernis, bei geklatschter Spinne: immer false
     */
    public boolean hindernisVorn() {
        if(!geklatscht) {
            int dx = 0;
            int dy = 0;
            int richtung = getRotation();
            switch(richtung) {
                case 0:
                    dx = 1; break;
                case 90:
                    dy = 1; break;
                case 180:
                    dx = -1; break;
                case 270:
                    dy = -1; break;
            }
            Actor klatsche = getOneObjectAtOffset(dx,dy,Hindernis.class);
            return klatsche != null;
        }
        else {
            return false;
        }
    }
    
    /**
     * Prüft, ob rechts neben der Spinne ein Hindernis liegt.
     * @return true: Hindernis, false: kein Hindernis, bei geklatschter Spinne: immer false
     */
    public boolean hindernisRechts() {
        if(!geklatscht) {
            int dx = 0;
            int dy = 0;
            int richtung = getRotation();
            switch(richtung) {
                case 0:
                    dy = 1; break;
                case 90:
                    dx = -1; break;
                case 180:
                    dy = -1; break;
                case 270:
                    dx = 1; break;
            }
            Actor klatsche = getOneObjectAtOffset(dx,dy,Hindernis.class);
            return klatsche != null;
        }
        else {
            return false;
        }
    }
    
    /**
     * Prüft, ob links neben der Spinne ein Hindernis liegt.
     * @return true: Hindernis, false: kein Hindernis, bei geklatschter Spinne: immer false
     */
    public boolean hindernisLinks() {
        if(!geklatscht) {
            int dx = 0;
            int dy = 0;
            int richtung = getRotation();
            switch(richtung) {
                case 0:
                    dy = -1; break;
                case 90:
                    dx = 1; break;
                case 180:
                    dy = 1; break;
                case 270:
                    dx = -1; break;
            }
            Actor klatsche = getOneObjectAtOffset(dx,dy,Hindernis.class);
            return klatsche != null;
        }
        else {
            return false;
        }
    }
    
    /**
     * Prüft, ob auf dem Platz der Spinne mindestens eine Fliege liegt.
     * @return true: Fliege(n) am Platz, false: keine Fliegen am Platz, bei geklatschter Fliege: immer false
     */
    public boolean fliegeAmPlatz() {
        if(!geklatscht) {
            Actor fliege = getOneObjectAtOffset(0,0,Fliege.class);
            return fliege != null;
        }
        else {
            return false;
        }
    }
    
    /**
     * Liefert die Anzahl der Fliegen auf dem Platz der Spinne.
     * @return die Anzahl der Fliegen auf Platz der Spinne, bei geklatschter Spinne: immer 0
     */
    public int fliegenAmPlatz() {
        if(!geklatscht) {
            List fliegen = getObjectsAtOffset(0,0,Fliege.class);
            return fliegen.size();
        }
        else {
            return 0;
        }
    }
    
    /**
     * Prüft, ob die Spinne mindestens eine Fliege gefressen hat.
     * @return true: Fliege(n) gefressen, false: keine Fliege gefressen, bei geklatschter Spinne: immer false
     */
    public boolean fliegeGefressen() {
        if(!geklatscht) {
            return fliegen > 0;
        }
        else {
            return false;
        }
    }
    
    /**
     * Liefert die Anzahl der Fliegen, die die Spinne gefressen hat.
     * @return die Anzahl der Fliegen, die die Spinne gefressen hat, bei geklatschter Spinne: immer 0
     */
    public int fliegenGefressen() {
        if(!geklatscht) {
            return fliegen;
        }
        else {
            return 0;
        }
    }

    /**
     * Schaltet die Anzeige von Fehlern und Warnungen ein.
     */
    private void nachrichtenZeigen() {
        if(!geklatscht) {
            nachrichten = true;
        }
    }
    
    /**
     * Schaltet die Anzeige von Fehlern und Warnungen aus.
     */
    private void nachrichtenVerbergen() {
        if(!geklatscht) {
            nachrichten = false;
        }
    }
}
```

und hier die Spinnenwelt:

```
import greenfoot.*;  // (World, Actor, GreenfootImage, and Greenfoot)
import java.util.List;
import javax.swing.JOptionPane;

/**
 * Klasse fÃ¼r Spinnen-Welt-Objekte.
 */
public class SpinnenWelt extends World
{

    /**
     * Erzeugt eine Welt mit 20x15 Feldern der GrÃ¶ÃŸe 40.
     * Die Welt ist mit gelben Bodenplatten belegt und von Hindernissen umrahmt.
     */
    public SpinnenWelt() {
        super(20, 15, 40);
        setBackground("images/bodenplatte.png");
        setPaintOrder(Klatsche.class, Spinne.class);
        randZiehen();
    }
    
    /**
     * Erzeugt eine Welt mit breite x hoehe Feldern der GrÃ¶ÃŸe 40.
     * Die Welt ist mit gelben Bodenplatten belegt und von Hindernissen umrahmt.
     * @param breite die Breite der Welt
     * @param hoehe  die HÃ¶he der Welt
     */
    public SpinnenWelt(int breite, int hoehe) {
        super(breite, hoehe, 40);
        setBackground("images/bodenplatte.png");
        randZiehen();
    }
    
    /**
     * Setzt ein Hindernis auf (x,y) sofern der Platz innerhalb der Welt liegt.
     * @param x die Spalte
     * @param y die Zeile
     */
    public void hindernisSetzen(int x, int y) {
        if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
            addObject(new Hindernis(),x,y);
        }
    }
    
    /**
     * Entfernt ein Hindernis von (x,y) sofern der Platz innerhalb der Welt liegt und dort eins liegt.
     * @param x die Spalte
     * @param y die Zeile
     */
    public void hindernisEntfernen(int x, int y) {
        if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
            List hindernisse = getObjectsAt(x,y,Hindernis.class);
            if(hindernisse.size() > 0) {
                removeObject((Actor)hindernisse.get(0));
            }
        }
    }
    
    /**
     * Setzt eine Klatsche auf (x,y) sofern der Platz innerhalb der Welt liegt.
     * @param x die Spalte
     * @param y die Zeile
     */
    public void klatscheSetzen(int x, int y) {
        if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
            addObject(new Klatsche(),x,y);
        }
    }
    
    /**
     * Entfernt eine Klatsche von (x,y) sofern der Platz innerhalb der Welt liegt und dort eine liegt.
     * @param x die Spalte
     * @param y die Zeile
     */
    public void klatscheEntfernen(int x, int y) {
        if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
            List klatschen = getObjectsAt(x,y,Klatsche.class);
            if(klatschen.size() > 0) {
                removeObject((Actor)klatschen.get(0));
            }
        }
    }
    
    /**
     * Setzt eine Fliege auf (x,y) sofern der Platz innerhalb der Welt liegt.
     * @param x die Spalte
     * @param y die Zeile
     */
    public void fliegeSetzen(int x, int y) {
        if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
            addObject(new Fliege(),x,y);
        }
    }
    
    /**
     * Entfernt eine Fliege von (x,y) sofern der Platz innerhalb der Welt liegt und dort eine liegt.
     * @param x die Spalte
     * @param y die Zeile
     */
    public void fliegeEntfernen(int x, int y) {
        if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
            List fliegen = getObjectsAt(x,y,Fliege.class);
            if(fliegen.size() > 0) {
                removeObject((Actor)fliegen.get(0));
            }
        }
    }
    
    /**
     * Setzt eine Spinne ohne Fliegen auf (x,y) sofern der Platz innerhalb der Welt liegt.
     * @param x die Spalte
     * @param y die Zeile
     */
    public void spinneSetzen(int x, int y) {
        if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
            addObject(new Spinne(),x,y);
        }
    }
    
    /**
     * Setzt eine Spinne mit einer gegebenen Anzahl Fliegen auf (x,y) sofern der Platz innerhalb der Welt liegt.
     * @param x die Spalte
     * @param y die Zeile
     */
    public void spinneSetzen(int x, int y, int fliegen) {
        if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
            addObject(new Spinne(fliegen),x,y);
        }
    }
    
    /**
     * Entfernt eine Spinne von (x,y) sofern der Platz innerhalb der Welt liegt und dort eine liegt.
     * @param x die Spalte
     * @param y die Zeile
     */
    public void spinneEntfernen(int x, int y) {
        if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
            List spinnen = getObjectsAt(x,y,Spinne.class);
            if(spinnen.size() > 0) {
                removeObject((Actor)spinnen.get(0));
            }
        }
    }
    
    private void randZiehen() {
        for(int i=0;i<getWidth();i++) {
            addObject(new Hindernis(),i,0);
            addObject(new Hindernis(),i,getHeight()-1);
        }
        for(int i=1;i<getHeight();i++) {
            addObject(new Hindernis(),0,i);
            addObject(new Hindernis(),getWidth()-1,i);
        }
    }
}
```

Hier mein Versuch mit einer neuen Methode der Spinne, aber ich bekomme immer die Fehlermeldung: "found int but expected boolean"

```
public int act3() 
    {
               if(!hindernisVorn()){
                for(int i = 0;i = i+1;i++){
                hindernisRechts();
    }    
    schritt();
}

    else{
        
        schritt();
}
}
```

Und hier noch die selbsterstellte Methode hindernisRechts:

```
public boolean hindernisRechts() 
    {
       
        boolean ergebnis = false;
        rechtsDrehen();
        ergebnis = hindernisVorn();
        linksDrehen();
        return ergebnis;
        
    }
```

Würde mich über Hilfe sehr freuen.


----------



## kirdie (3. Dez 2010)

Der Kopf deiner For-Schleife ist sicher nicht dass, was du wolltest:


```
for(int i = 0;i = i+1;i++){
```

Eine For-Schleife funktioniert in Java so:


```
//allgemeiner Aufbau
for ( Zählvariable mit Anfangswert; Bedingung; Schrittweite) {
      // Anweisung, die wiederholt werden soll
}
 
// hochzählen in 1er-Schritten
for ( int zählvariable = Anfangswert; zählvariable <= Endwert; zählvariable++ ) {
      // Anweisung, die wiederholt werden soll
}
```

Deine Bedingung ist nun "i=1+1", das erhöht also i um 1 und gibt dann gleichzeitig noch als Nebeneffekt den neuen Wert von i zurück. Der Wert von i ist aber eine Zahl und eine Bedingung (also was da hin muss) ist ein Wahrheitswert (also boolean). Da der Typ der dort steht nicht gleich ist mit dem Typ den Java will, gibt es zum Glück eine Fehlermeldung. In anderen Sprachen wie z.B. C++ würde es da meiner Meinung nach gar keinen Fehler geben, da dort auch Vergleiche zwischen Boolean und Integertypen zulässig sind, nur dass dann oft nicht das passiert, was man denkt.

P.S.: Du hast doch in deinem Originalcode schon eine Methode hindernisRechts(), warum brauchst du noch eine? Außerdem musst du das Resultat noch abfragen und bei positivem Ergebnis den Hinderniszähler erhöhen.


----------



## CT (3. Dez 2010)

Könntest du die Änderungen in den Quelltext schreiben? Irgendwie versteh ich das so nicht. Ich weiß nicht wie man die Hindernisse abfragt. Die schon vorhandene Methode hindernisRechts hatte ich nicht gesehen.


----------



## CT (5. Dez 2010)

Weiß niemand die Lösung? Morgen muss ich es abgeben.


----------

