Kara Kleeblätter aufsammeln lassen(automatisch)

[!lkay]

Hallo,

wir müssen in Informatik mit JavaKara arbeiten.

Unsere Aufgabe besteht nun darin, den Käfer alle Kleeblätter aufsammeln zu lassen.

Die anderen haben einfach konstante Turns für das aktuelle Feld mit der aktuellen Itemaufstellung, was wir bekommen haben (18 Felder breit, 6 Felder hoch), genommen.

Das möchte ich eher nicht, denn die nächste Aufgabe wird sowieso sein, den Käfer vollautomatisiert laufen zu lassen.


So sieht das Feld aus:



Momentan sieht mein Codeversuch so aus:

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

public class einstiegsprogramm1 extends JavaKaraProgram {
  public void myProgram() {
      kara.turnLeft();
    while (true) {
      if (kara.treeFront() ||  kara.mushroomFront()) {
          
      if (!kara.treeRight())
{ 
kara.turnRight();
kara.move();
kara.turnLeft(); 
}
      if (!kara.treeLeft()) 
{
kara.turnLeft();
kara.move();
kara.turnRight();
         }
    }
 if (kara.onLeaf()) kara.removeLeaf();
 kara.move();
    }
}
} 

Leider scheint da irgendwo ein Fehler zu sein. Kann mir jemand helfen?

[milchbubix]

Wir haben/hatten in der schule, theoretisch das gleiche, nur mit einem JavaHamser der körner aufsammeln konnte

Wo ist denn der Fehler? Also sagt dir das Programm nicht irgendeine Fehlermeldung?

[!lkay]

Kara läuft gegen einen Baum.. Irgendwo scheint in meinem Code also ein Fehler zu stecken.

[patlux]

Wenn du Hilfe erwartest, dann formatier bitte mal den Code richtig. Sowas werde zumindest ich nicht lesen.

[Gelöschter Benutzer]

------

[Mr. White]

Finn, das Vieh wird sich da nur im Kreis drehen.

@TE
Das was du vorhast, alle Kleeblätter bei beliebiger Weltkonfiguration einzusammeln, ist nicht so trivial, wie du vielleicht dachtest. Mir fällt kein Algorithmus ein, der zum gewünschten Ergebnis führt.

[!lkay]

Damit läuft er immer linksherum..

Edit :Sorry, da kam wohl zwischenzeitlich noch ein Post.

Besteht denn die Möglichkeit den Käfer automatisch die Kleeblätter aufsammeln zu lassen, wenn ich die .world Datei auslese und somit die Positionen der Items kenne? Dann müsste es doch funktionieren oder?

[Gelöschter Benutzer]

------

[Mr. White]

A*-Algorithmus

import javakara.*;
import java.util.*;
import java.math.*;
import java.awt.Point;
        
public class AStern extends JavaKaraProgram {
  private final List<PathPoint> listOfTreesAndMushrooms = new ArrayList<>();
  private final List<PathPoint> listOfLeafs = new ArrayList<>();

  public void myProgram() {
    for(int x = 0; x < world.getSizeX(); ++x) 
      for(int y = 0; y < world.getSizeY(); ++y)
        if(world.isTree(x, y) || world.isMushroom(x, y))
          listOfTreesAndMushrooms.add(new PathPoint(x, y));
        else if(!world.isMushroom(x, y) && world.isLeaf(x, y))
          listOfLeafs.add(new PathPoint(x, y));
    while(!listOfLeafs.isEmpty()) {
      PathPoint start = new PathPoint(kara.getPosition().x,kara.getPosition().y);
      PathPoint end = getNearestLeaf(start);
      followPath(getPath(start, end));
      kara.removeLeaf();
      listOfLeafs.remove(end);
    }
  }

  private void followPath(Stack<Point> path) {
    int size = path.size();
    for(int i = 0; i < size; ++i) {
      Point nextPoint = path.pop();
      kara.setPosition(nextPoint.x, nextPoint.y);
    }
  }

  private Stack<Point> getPath(PathPoint start, PathPoint end) {
    List<PathPoint> openList = new ArrayList<>(), closedList = new ArrayList<>();
    openList.add(start);
    while(!closedList.contains(end) || openList.isEmpty()) {
      Collections.sort(openList, PathPoint.comparator);
      start = openList.get(0);
      openList.remove(start);
      closedList.add(start);
      for(PathPoint neighbour : getWalkableNeighbours(start))
        if(!closedList.contains(neighbour)) {
          neighbour.setPreviousPoint(start);
          neighbour.computeCosts(end);
          if(!openList.contains(neighbour))
            openList.add(neighbour);
        }
    }
    Stack<Point> path = new Stack<>();
    PathPoint point = closedList.get(closedList.indexOf(end));
    while(point.getPreviousPoint() != null) {
      path.push(point);
      point = point.getPreviousPoint();
    }
    return path;
  }

  private List<PathPoint> getWalkableNeighbours(Point currentPoint) {
    List<PathPoint> walkableNeighbours = new ArrayList<>();
    List<PathPoint> neighbours = new ArrayList<>();
    if((currentPoint.y - 1) >= 0)
      neighbours.add(new PathPoint(currentPoint.x, currentPoint.y - 1));
    if((currentPoint.x + 1) < world.getSizeX())
      neighbours.add(new PathPoint(currentPoint.x + 1, currentPoint.y));
    if((currentPoint.y + 1) < world.getSizeY())
      neighbours.add(new PathPoint(currentPoint.x, currentPoint.y + 1));
    if((currentPoint.x - 1) >= 0)
      neighbours.add(new PathPoint(currentPoint.x - 1, currentPoint.y));
    for(PathPoint neighbour : neighbours)
      if(!listOfTreesAndMushrooms.contains(neighbour))
        walkableNeighbours.add(neighbour);
    return walkableNeighbours;
  }

  private PathPoint getNearestLeaf(PathPoint currentPoint) {
    for(PathPoint leaf : listOfLeafs) 
      leaf.computeCosts(currentPoint);
    Collections.sort(listOfLeafs, PathPoint.comparator);
    return listOfLeafs.get(0);
  }
}

class PathPoint extends Point {
  public final static Comparator<PathPoint> comparator = new Comparator<PathPoint>() {
    @Override
    public int compare(PathPoint p1, PathPoint p2) {
      if(p1.getSumOfCosts() < p2.getSumOfCosts())
        return -1;
      else if(p1.getSumOfCosts() > p2.getSumOfCosts()) 
        return 1;
      return 0;
    }
  };

  private PathPoint previousPoint = null;
  private int movementCosts = 0, estimatedCosts = 0;
	
  public PathPoint(int x, int y) {
    super(x, y);
  }

  public void computeCosts(PathPoint end) {
    movementCosts = previousPoint!=null ? previousPoint.getMovementCosts()+10 : 10;
    estimatedCosts = (Math.abs(end.x - x) + Math.abs(end.y - y)) * 10;
  }

  public void setPreviousPoint(PathPoint previousPoint) {
    this.previousPoint = previousPoint;
  }

  public PathPoint getPreviousPoint() { return previousPoint; }
  public int getMovementCosts() { return movementCosts; }
  public int getEstimatedCosts() { return estimatedCosts; }
  public int getSumOfCosts() { return movementCosts + estimatedCosts; }
}

Leider kann über die Kara-Instanz nicht ihre Richtung ermittelt werden. Deswegen wird ihre Anfangsrichtung immer beibehalten, aber ansonsten bin ich mit dem Ergebnis zufrieden.

Getestet mit Welten wie: