x Schritte zählen

[tfausw]

Guten Morgen zusammen,

vorerst Entschuldigung für mögliche banale Fehler, ich bin noch am Anfang an meiner Java Karriere .

Folgendes: Wir lernen mit kara. Es soll quasi einfach jede 5 Schritte nun ein Blatt gelegt werden, d.h., dass ich eine Methode für das kara.putLeaf() (Methode zum Blatt legen) geschrieben habe, die wie folgt lautet:

public int put() {
      int ww = 20; // WorldWidth
    
      for (int step =0; step <= ww; step ++) {
        if (step % 5 == 0) {          
            kara.putLeaf();                    
        }
        else {
            kara.move();
      }
   }
   return ww;
  }

Also wenn ich meinen Code in deutsch "übersetzen" sollte, würde ich sagen, dass die Weltbreite 20 Felder beträgt, wir eine Schritt(step) Variable deklarieren die mit der Zahl 0 anfängt. Step darf nur kleiner gleich worldwidth sein und step summiert sich pro Durchlauf um +1. Wenn step durch 5 teilbar ist und der Rest 0 beträgt, wird kara.putLeaf() ausgeführt. Ansonsten wird ein Schritt gemacht.
Beim return ww; am Ende bin ich mir eher unsicher ob es überhaupt Sinn macht diesen Wert zurückzugeben (ich schätze mal eher nicht?)


Nun ist das Problem, dass wenn ich das Programm ausführe, nur nach 4 Schritten das Blatt gelegt wird, anstatt wie nach gewollten 5.

Für jeglichen Hinweis und Denkanstöße, damit ich daraus lerne, wäre ich sehr dankbar.

Schönen Tag und schönes Wochenende zusammen

 

[Xyz1]

Wie wärs mit Code Tags?

 

[tfausw]

Wie wärs mit Code Tags?

Tut mir leid, bin neu, habe es mal geändert.

 

[Javinner]

@tfausw

int ww = 20;
(int step =0; step <= ww; step ++)

Hier läufst du aber einundzwanzig Schritte Außerdem vergisst du einmal zu gehen, wenn der Schritt Modulo 5 Null ist. Scha u, Java-Hamster macht es richtig

 

[tfausw]

Hier läufst du aber einundzwanzig Schritte Außerdem vergisst du einmal zu gehen, wenn der Schritt Modulo 5 Null ist.

Super, danke! Jetzt legt kara jede 5 Schritte ein Blatt. Jetzt muss ich nur noch den Zeilenwechsel optimieren und schauen warum kara am Anfang nach 2 Schritten ein Blatt legt

 

[Javinner]

@tfausw
Und wenn du schon dabei bist: an letzter Kachel, an der der Käfer den Blatt ablegt, sollte der Käfer auch stehen bleiben. Da baue ich ein Fehler ein und keiner merkt es

 

[tfausw]

Soweit so gut ... naja oder auch eher nicht. Nun wird jeder 5. Schritt in meiner Zeile ein Blatt gelegt, das ist ja auch ganz in Ordnung fürs erste. Nur wird es tatsächlich auch nur für eine Zeile ausgeführt, obwohl mein "Spielbrett" sozusagen 20x15 groß ist. Jetzt tüftel ich seit ca. 2 Stunden daran rum, warum aber es eben nur für eine Zeile ausgeführt wird, aber ich finde einfach nicht meinen Fehler weshalb entweder die Schleife ausbricht o.ä.

Der Zeilenwechsel funktioniert nicht, zudem soll weitergezählt werden, d.h. nicht einfach pro Zeile 5 Schritte, sondern mit Zeilenwechsel 5 Schritte. Ich war eben so weit, dass kara in jeder Zeile pro 5 Schritte ein Blatt gelegt hat, aber wie erwähnt soll es von oben links bis unten rechts durchzählen und jeden 5. Schritt ein Blatt legen. Nun habe ich meinen Code so verranzt, dass ich kaum noch durchblicke wo mein Fehler ist.

boolean leaf = false;
 
  public void put() {
      // jede 5 Schritte ein Blatt legen
      int ww = 20; // WorldWidth
  
      for (int step =0; step < ww; step ++) {
        if (step % 5 == 0) {        
         
            kara.putLeaf(); 
             kara.move();
    
      //  if (kara.treeFront()) {
        //    changeRow();
     // }
    }
        else {
          if (!kara.treeFront()) {
              kara.move();
        }
       }
   }
  }
 
 
  public void changeRow() {
     // Blickrichtung ändern
      if (kara.treeRight() && !kara.treeFront()) {
          kara.turnLeft();
      } else if (kara.treeFront() && kara.treeLeft()) {
          kara.turnRight();
      } else if (kara.treeFront() && kara.treeRight()) {
          kara.turnLeft();
          kara.turnLeft();
      }
  }

public void leafChess() {
  
// Schleife zum Ausführen
    while(true) {
        put();
        if (kara.treeFront()) {
            changeRow();
        }
        while (!kara.treeFront()) {
          put();
          }
    
        kara.turnRight();
        if (kara.treeFront()) {
            break;
        }
        put();
        kara.turnRight();
        while (!kara.treeFront()) {
        put();
        }
        kara.turnLeft();
        if (kara.treeFront()) {
            break;
        }
        put();
        kara.turnLeft();
  
      }
    }

Was da jetzt passiert ist, dass in meinem Spielfeld ( 20x15 ) quasi im Kreis blätter gelegt werden, also völlig am Ziel vorbei weil dieser Zeilenwechsel nicht funktioniert bzw. beim Zeilenwechsel nicht weitergezählt und weiter jeden 5. Schritt ein Blatt gelegt wird.

Ich hoffe, dass ich das hier nicht all zu verwirrend verfasst habe und über Ratschläge und Denkanstöße wäre ich unendlich dankbar.

Also nochmal kurz: anstatt einem Zeilenwechsel läuft das Programm im Kreis und ich finde den Fehler nicht

 

[Javinner]

Wenn ich dich jetzt richtig verstanden habe, willst du ein Feld W x H ablaufen und jeweils links und rechts in die nächste mögliche Zeile wechseln, um auf jeder fünften Kachel ein Kleeblatt abzulegen und das solange, bis das Feld eben zu Ende ist.
Schauen wir die möglichen Grundbefehle, die der Käfer versteht.

• kara.move() Kara läuft einen Schritt vorwärts
• kara.turnRight() Kara dreht sich an Ort und Stelle nach rechts
• kara.turnLeft() Kara dreht sich nach links
• kara.putLeaf() Kara legt ein Kleeblatt ab (an der Stelle, wo Kara steht)
• kara.removeLeaf() Kara nimmt ein Kleeblatt auf (an der Stelle, wo er steht)

In JavaKara gibt es Sensoren, mit denen die Umgebung überprüft werden kann:

• kara.treeFront() Gibt es einen Baum auf dem Feld unmittelbar vor Kara?
• kara.treeLeft() Gibt es einen Baum auf dem Feld links von Kara?
• kara.treeRight() Gibt es einen Baum auf dem Feld rechts von Kara?
• kara.mushroomFront() Gibt es einen Pilz auf dem Feld vor Kara?
• kara.onLeaf() Steht Kara auf einem Kleeblatt?

Bewegung im Raum:
Gehen wir davon aus, dass Kara bereits in der linken oberen Ecke steht, Blickrichtung OST. Ein Feld W x H erstreckt sich vor dem Käfer nach Süden und Ost verlaufend. Was sind denn die Grenzen des Feldes? Der Befehlsliste entnehme ich, dass ein Baum oder eine Baumreihe eine mögliche Grenze bilden können. Also soll der Käfer bis zum Baum laufen. Wenn er dann vor dem Baum steht und rechts aber kein Baum steht, dann existiert ja eine weitere Reihe. Die selbe Vorgehensweise auf der anderen Seite: wenn der Käfer vor dem Baum steht, Blickrichtung WEST, und links von ihm kein Baum existiert, existiert eine weitere Reihe. Nun braucht es noch eins, zumindest denke ich, dass es hier notwendig ist und lasse mich gern des Anderen belehren, und zwar die Variable für die Blickrichtung, so dass der Käfer im Falle eines Wechsels in die nächste mögliche Reihe stets weiß, in welche Richtung er gerade blickt. Eventuell spielt die Variable bei der End-Bedingung eine wichtige Rolle..

Kleeblatt-Management:
Hier muss man nur letztendlich die Schritte beim Wechsel in die nächstmögliche Reihe mitzählen. Das haben wir ja schon besprochen.

Programmtest:
Hier wird es knifflig, denn dein Programm muss für

• eine Kachel
• eine eine Kachel weite horizontale Reihe
• eine eine Kachel breite vertikale Reihe
• ein Feld von W x H

all diese Felder funktionieren. Das gute dabei, all diese Felder haben das selbe Ende und der Käfer sollte erkennen, ob er sich am Ende eines Feldes befindet Also könnte das Programm so lauten:

do{
    bearbeiteEineReihe;
    wenn(weitereReiheExistiert und Blickrichtung OST)
             wechelRechtsEin()
    wenn(weitereReiheExistiert und Blickrichtung WEST)
             wechselLinksEin()
} while(endeDesFeldesErreicht());

Anschließend prüfen, ob die letzte Kachel für ein Kleeblatt bestimmt ist
Viel Erfolg!

 

[Javinner]

kara.turnLeft();
kara.turnLeft();

Damit dein Code besser, kürzer und verständlicher wird, fasse doch die Bewegungsabläufe, die nicht zu dem Grundsatz der Befehle gehören, in deine eigene Methoden zusammen.
Hier würde ich eher so vorgehen:

public void turn180()
{
     kara.turnLeft();
     kara.turnLeft();
}

Dann die Mehtode:

public void leafChess() {
 
// Schleife zum Ausführen
    while(true) {
        put();
        if (kara.treeFront()) {
            changeRow();
        }
        while (!kara.treeFront()) {
          put();
          }
   
        kara.turnRight();
        if (kara.treeFront()) {
            break;
        }
        put();
        kara.turnRight();
        while (!kara.treeFront()) {
        put();
        }
        kara.turnLeft();
        if (kara.treeFront()) {
            break;
        }
        put();
        kara.turnLeft();
 
      }
    }

Hm... Gehe doch die Methode durch und schreibe dir sequentiell auf, was hier passiert..

 

[Xyz1]

Das legt ein wie ich finde interessantes Muster:

import javakara.JavaKaraProgram;
        
/* BEFEHLE:  kara.
 *   move()  turnRight()  turnLeft()
 *   putLeaf()  removeLeaf()
 *
 * SENSOREN: kara.
 *   treeFront()  treeLeft()  treeRight()
 *   mushroomFront()  onLeaf()
 */
public class KaraTest extends JavaKaraProgram {

  // hier können Sie eigene Methoden definieren

  public void myProgram() {
    // hier kommt das Hauptprogramm hin, zB:
    int steps = 0;
    while (true) {
      if (steps%5 == 0) {
          if (kara.onLeaf()) {
            kara.removeLeaf();
          if (kara.treeLeft())
            kara.turnRight();
          if (kara.treeRight())
            kara.turnLeft();
          } else {
            kara.putLeaf();
          }
      }
      while(kara.treeFront())
        kara.turnLeft();
      kara.move();
      steps++;
    }
  }
}

 

[Javinner]

@DerWissende Hat eine Minute meines Lebens gekostet!

 

[Xyz1]

@DerWissende Hat eine Minute meines Lebens gekostet!

Um das "Spielfeld" herum muss eine Reihe mit Bäumen stehen zur Begrenzung!

 

[Javinner]

Na ja, über die Schönheit sollte man sich nicht streiten

 

[Xyz1]

@mihe7 Was ist hier los?

 

[tfausw]

Guten Morgen,

vorerst Entschuldigung falls mein letzter Post irgendwie ziemlich konfus war. Ich habe mir gestern viele Stunden den Kopf darüber zerbrochen, was für euch vermutlich unverständlich ist, aber ich möchte das gerne verstehen, vielleicht war es auch einfach zu spät oder was auch immer. nun ja, neuer Tag neues Glück. Ich bedanke mich schon mal für die Unterstützung und werde mich zeitnah damit befassen und werde es dann hoffentlich heute schaffen

 

[mihe7]

@DerWissende keine Ahnung. Käfer, Hamster, Baumgrenzen, Kleeblätter - Leute, was habt ihr geraucht?!?

 

[Javinner]

@DerWissende keine Ahnung. Käfer, Hamster, Baumgrenzen, Kleeblätter - Leute, was habt ihr geraucht?!?

Da gibt es noch Körner!

 

[mihe7]

Da gibt es noch Körner!

Wusst ich's doch: Gras kann es nicht gewesen sein.

 

[Javinner]

Für die Nachwelt:
Bezogen auf mein Post Nr.: #8 kommt jetzt eine Lösung des Problems nach beschriebener Strategie, welche für alle Territorien funktioniert (siehe Bilder). Zu beachten ist: es wurde mit dem Java-Hamster umgesetzt, will heißen, ich habe die Grundbefehle des Hamsters an die des Käfers angepasst.

Spoiler: Code

/** zeilenWechsel
Blickrichtung OST = false
Blickrichtung WEST = true
*/
boolean zeilenWechsel = false;
/** Schrittzaehler */
int schritt = 0;
/** Kornabstand */
int modulo = 5;
void main() {
 
   do{
       bearbeiteEineReihe();
       if(!zeilenWechsel && ! treeRight() && treeFront())
       {
           zeilenWechselRechts();
       }
       if(zeilenWechsel && !treeLeft() && treeFront())
       {
           zeilenWechselLinks();
       }
   } while(!feldBearbeitet());
   /**
   Wenn das Feld nur aus einer Kachel besteht oder es sich
   um das letzte Feld, welches zu belegen ist, handelt
   */
   if(placeToLeaf())
   {
         putLeaf();
   }
 
}


public boolean feldBearbeitet()
{
    return !zeilenWechsel && treeRight() && treeFront()
            ||
            zeilenWechsel && treeLeft() && treeFront();
}

public void bearbeiteEineReihe()
{
    while(!treeFront())
    {
        moveAndPut();
    }
}

public void moveAndPut()
{
    if(placeToLeaf())
    {
        putLeaf();
        move();
        schritt++;
    } else {
        move();
        schritt++;
    }
}

public boolean placeToLeaf()
{
    return schritt % modulo == 0;
}

public void zeilenWechselRechts()
{
    turnRight();
    moveAndPut();
    turnRight();
    zeilenWechsel = true;
}

public void zeilenWechselLinks()
{
    turnLeft();
    moveAndPut();
    turnLeft();
    zeilenWechsel = false;
}
//-------------------------------------------------------------------------Translated to Java-Hamster
public void move()
{
    vor();
}

public void turnRight()
{
    linksUm();
    linksUm();
    linksUm();
}

public void turnLeft()
{
    linksUm();
}

public void putLeaf()
{
   gib();
}

public void removeLeaf()
{
    nimm();
}

public boolean treeFront()
{
    return !vornFrei();
}

public boolean treeLeft()
{
    turnLeft();
    boolean value = treeFront();
    turnRight();
    return value;
}

public boolean treeRight()
{
    turnRight();
    boolean value = treeFront();
    turnLeft();
    return value;
}


public boolean onLeaf()
{
    return kornDa();
}

Viel Spaß