Wegberechnung mit Greenfoot

[thoff430]

Hallo miteinander!

Bei der aktuellen Aufgabe (es wird wieder Greenfoot verwendet) muss ich versuchen, das Huhn im kürzesten Weg um den Zaun zu schicken um dann wieder zur Ausgangsposition zurückzukehren.



Ich bin schon eine ganze Weile am überlegen, wie meine detectFence()-Methode aussehen soll..und ich komm auf kein schönes, "kompaktes" Ergebnis, dass nicht so überaus verschachtelt ist. Außerdem kam jetzt noch eine Enumeration hinzu mit der wir etwas anfangen sollen...und ich keine Ahnung habe wie sie mir in dem Fall nützlich sein kann.

Zum Glück ist die Aufgabenstellung diesmal auf Englisch und nicht auf Niederländisch...also wer interessiert ist, kann mal einen Blick drauf werfen (die benötigte Info ist um einiges kürzer als der gesamte Text .. das ganze Zeugs mit stepTpULCorner dient nur zur Demonstration und hat nichts mit der eigentlichen Aufgabe zu tun ): opdracht5

Kann mir da jmd auf die Sprünge helfen?

 

[Marcinek]

Titel?

Du min erst die Qualität deiner antworten mit dummen Titeln.

Die enums würde ich fuer die einzelene Objekte verwenden. Und jedes Feld mit einer Methode getobject ausstwtten und wenn das fence ist dann reagieren.

 

[Noctarius]

Demnächst werden Threads mit solch dummen Titeln kommentarlos gelöscht! Also wenigstens ein wenig Mühe kann man sich doch wohl geben.

 

[thoff430]

Oh Gosh! Ich hab den Titel ganz vergessen! :autsch: :autsch: Der Unsinn wurde nur gebraucht, um die Vorschaufunktion zu benutzen, das war so nicht beabsichtigt.

@ Marcinek: Wie krieg ich denn auf ne vernünftige Weise die Felder ausgewertet? Eine Fallunterscheidung zu anderen Objekten ist denke ich nicht nötig, es können eigentlich nur Zäune im Weg sein und nix anderes. Allerdings werde meine Lösungen irgendwie unnötig lang (Bsp: falls huhn nach norden läuft, dreh nach westen, guck ob ein zaun da ist, falls ja dann...sonst, dreh nach süden...und so weiter.... falls huhn nach westen läuft dann ...). Das muss doch irgendwie eleganter gehen.

@ Mod: Danke für die Titeländerung!

 

[Kevin94]

Ich würde die Richtung in die das Huhn schaut bei deinem Bewegungsalgorithmus gar nicht mit einbeziehen. Nur in Methoden wie z.B. "istVorneZaun", "istRechtsZaun", "dreheLinks", "dreheRechts", "schritt". (Nach der von dir in nem anderen Thread geposteten Klasse, sind einige davon schon in Chicken implementiert)

Den eigenlichen Algorithmus würde ich dann nur auf diesen Methoden aufbauen.

 

[Marcinek]

Wenn das Huhn erst gucken soll wohin es läuft dann musst es erst drehen.

Und da ist das schon ok so. Du musst dir ja merken was auf dem Feld ist. Und das machst du mit enums, weil es kann schon ein Zaun und ein Huhn sein.

Später kommt noch ein Stein... Und daher ist es Sinnvoll hierfür die Enums zu nehmen.

Gruß

Martin

 

[thoff430]

Später kommt kein Stein, das ist nicht Teil der Aufgabe. Der "Stein" wurde nur zur Wegverfolgung gebraucht, wenn man eine while-schleife gebraucht. Auch andere Hühner zu beachten geht über die Aufgabenstellung hinaus. Klar kann man versuchen das Programm so perfekt wie möglich hinzukriegen...aber dann wird man nie fertig. Wenn es nur darum geht ein Huhn auf dem kürzesten Weg um einen beliebigen Zaun zu schicken, dann ist genau das auch die Aufgabe, nicht mehr..vorerst.

 

[Marco13]

Code, den man schnell in Greenfoot testen kann wäre hilfreich, für die die sich nicht den ganzen Tag damit beschäftigen.

 

[emailundlos]

Was mir als erstes dazu einfiel: Hat der Zaun eine Lücke? Kann das Huhn rüberhüpfen/fliegen? Kann dem Huhn jemand herüber oder herum helfen. 3 verschiedene Sichtweisen für das gleiche Prob. ;-)

 

[thoff430]

@ Marco13 Code kommt, wenn ich weiterhin stecken bleibe Noch bin ich selbst am rumtüfteln und rumprobieren. Hab ja hier schon einige Tipps bekommen die ich nun versuche einzubauen.

@ emailundlos Nein, der Zaun hat keine Lücke aber gute Frage. Ich denke, dass das Ganze auch funktionieren sollte, wenn der Zaun eine Lücke hat. Wenn ich das Huhn so programmiere, dass es sich so eng es geht am Zaun orientiert, dann sollte es bei einem Zaun mit Lücke auch wunderbar klappen. Das Huhn kann allerdings nicht fliegen und Hilfe ist auch nicht erlaubt Es muss nach getaner Arbeit allerdings zurück zum Startplatz laufen.

edit: Mal ein wenig Code, ich kopier einfach mal die komplette Klasse Chicken und Barnfield hier hinein. Sieht nach viel aus, aber der Großteil wird für die Aufgabe eh nicht gebraucht. Dieser Code ist unbearbeitet, das ist das "Ausgangsmaterial" mit dem wir beginnen sollten.

import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)

/**
 * Write a description of class Chicken here.
 * 
 */
public class Chicken  extends Actor
{
    private static final int EAST  = 0, WEST  = 1, NORTH = 2, SOUTH = 3;

    private int direction;
    private GreenfootImage chickenRight, chickenLeft;

    
    public Chicken () {
        chickenLeft = getImage();
        chickenRight  = new GreenfootImage(chickenLeft);
        chickenRight.mirrorHorizontally();
        setDirection(WEST);
    }


    /**
     * Check whether there is an egg in the same cell as we are.
     */
    public boolean foundEgg() {
        return getOneObjectAtOffset(0, 0, Egg.class) != null;
    }
    
     /**
     * Check whether there is a fence ahead of us.
     */
    public boolean fenceAhead() {
        Actor may_be_fence = null;
        if (direction == SOUTH) {
             may_be_fence =  getOneObjectAtOffset(0, 1, Fence.class);
        } else if (direction == EAST) {
             may_be_fence =  getOneObjectAtOffset(1,0, Fence.class);
        } else if (direction == NORTH) {
             may_be_fence =  getOneObjectAtOffset(0,-1, Fence.class);
        } else /* direction should be WEST here */{
             may_be_fence =  getOneObjectAtOffset(-1,0, Fence.class);
        }
        if (may_be_fence == null) {
            return false;
        }
        else {
            return true;
        }
    
    }
        
    public void layEgg() {
        getWorld().addObject(new Egg (), getX (), getY ());
    }
    
    public Egg takeEgg() {
        Actor egg_actor = getOneObjectAtOffset(0, 0, Egg.class);
        if (egg_actor != null) {
            return (Egg) egg_actor;
        } else {
            ShowError ("There was no egg in this cell");
            return null;
        }
    }

     public boolean facingNorth () {
        return direction == NORTH;
     }
    
     
    /**
     * Move one cell forward in the current direction.
     */

    public void move()
    {
        if (! borderAhead()) {
            if (! fenceAhead ()) {
                if (direction == SOUTH) {
                    setLocation(getX(), getY() + 1);
                } else if (direction == EAST) {
                    setLocation(getX() + 1, getY());
                } else if (direction == NORTH) {
                    setLocation(getX(), getY() - 1);
                } else /* direction should be WEST here */{
                    setLocation(getX() - 1, getY());
                }
            } else {
                ShowError ("A fence was blocking the way");
            }
        } else {
            ShowError ("End of the world reached");
        }
    }

    /**
     * Test if we can move forward. Return true if we can, false otherwise.
     */
    public boolean canMove()
    {
        if (fenceAhead () || borderAhead ()) {
            return false;
        } else {
            return true;
        }
    }
    
    /**
     * Test is a cell ahead of us.
     */
    private boolean borderAhead () {
        if (direction == SOUTH) {
             return getY() == getWorld().getHeight() - 1;
        } else if (direction == EAST) {
             return getX() == getWorld().getWidth()  - 1;
        } else if (direction == NORTH) {
             return getY() == 0;
        } else /* direction should be WEST here */{
             return getX() == 0;
        }
    }

    /**
     * Turns towards the left.
     */
    public void turnLeft() {
        if (direction == SOUTH) {
             setDirection(EAST);
        } else if (direction == EAST) {
             setDirection(NORTH);
        } else if (direction == NORTH) {
             setDirection(WEST);
        } else /* direction should be WEST here */{
             setDirection(SOUTH);
        }
    }

    /**
     * Sets the direction we're facing.
     */
    public void setDirection(int direction){
        direction = direction % 4;
        if (this.direction != direction) {
            this.direction = direction;
            if (direction == SOUTH) {
                setImage(chickenRight);
                setRotation(90);
            } else if (direction == EAST) {
                setImage(chickenRight);
                setRotation(0);
            } else if (direction == NORTH) {
                setImage(chickenLeft);
                setRotation(90);
            } else /* direction should be WEST here */{
                setImage(chickenLeft);
                setRotation(0);
            }
        }
    }
    
    public static int randomDirection () {
        return Greenfoot.getRandomNumber (4);
    }
    
    private void ShowError (String err_msg) {
        World my_world = getWorld();
        my_world.addObject (new Alert (err_msg),my_world.getWidth()/2, my_world.getHeight()/2);
        Greenfoot.stop();
    }

}

import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)

/**
 * Write a description of class Fryde here.
 * 
 */
public class Barnfield  extends Chicken
{

   
    public void act() {
        goToULCorner ();
    }
    
    private void goToULCorner ()
    {
       turnNorth ();
       walkToBorder ();
       turnLeft ();
       walkToBorder ();
    }       
            
    private void turnNorth () {
        while (! facingNorth ())
            turnRight ();
    }
    
    private void walkToBorder () {
        while (canMove ())
            move ();
    }
    
    enum Task { TurningNorthwards, WalkingUpwards, TurningLeft, WalkingLeftwards, JobDone };
    
    private Task currentTask;
    
    public Barnfield () {
        currentTask = Task.TurningNorthwards;
    }
    
    private void stepToULCorner () {
        if (currentTask == Task.TurningNorthwards){
                if (facingNorth ()) {
                    currentTask = Task.WalkingUpwards;
                } else {
                    turnRight ();
                }
        } else if (currentTask == Task.WalkingUpwards){
                if (canMove ()) {
                    move ();
                } else {
                    currentTask = Task.TurningLeft;
                }
        } else if (currentTask == Task.TurningLeft){
                turnLeft ();
                currentTask = Task.WalkingLeftwards;
        } else if (currentTask == Task.WalkingLeftwards){
                if (canMove ()) {
                    move ();
                } else {
                    currentTask = Task.JobDone;
                }
        }
    }  

   /**
     * To make a 180 degree turn
     */
    public void turn () {
        turnLeft ();
        turnLeft ();
    }

    /**
     * Turns towards the right.
     */
    public void turnRight() {
        turnLeft ();
        turnLeft ();        
        turnLeft ();
    }
    
 
    /**
     * Make a step backwards
     */
    public void moveBackwards () {
        turn ();
        move ();
        turn ();
    }
    
    private void moveAndMark () {
        dropPebble ();
        move ();
    }

    private void dropPebble () {
        getWorld().addObject (new Pebble (), getX (), getY ());
    }


}

 

[emailundlos]

Ein Lattenzaun mit Zwischenraum, um durchzuschauen. ;-)

Lass das Huhn vor laufen, dann rechts drehen, und dann nur noch links drehen, insofern sich dort kein Zaun befindet, bis es wieder dort ist, wos startete.