# Roboter Bewegen



## Leno (9. Apr 2011)

Hi ,

stehe vor einem Problem, das ich nicht lösen kann. Folgendes ist die Aufgabe.
Ein Roboter soll sich stets gegen den Uhrzeigersinn in einem Rechteck bewegen.
So also den Robo haben wir bereits vorgegeben bekommen, das Rechteck kriege ich auch hin.
Meine Idee war es den Robo auf eine art schiene zu setzen die er entlang läuft. Lieder 
habe ich keine Idee wie ich ihn entlang des Rechteckes bewegen soll ? gibt es da einen Algo ? 
und wenn ja welche  ? mit einer if else abfrage ist die sache kaum möglich ?

Ich habe mal beide Klassen reingestellt:


```
public class Waechter_Roboter extends Roboter {

	private Rechteck r;  // Das Rechteck sollte als ein Attribut der Klasse gesehen werden. 
	
	
	public Waechter_Roboter( int x , int y , int richtung ){
		
		super(x,y,richtung);
		
         r = new Rechteck(x,y, x,y-4,x+4,y-4,x+4,y); 	// Jeder Roboter bekommt ein Rechteck zugewiesen.	
	
	}
	
	
	
	@Override
	public void move() {
		// TODO Auto-generated method stub
	
		// Positionierung der Richtung.
		if(getDirection() == 0 | getDirection() == 1| getDirection()  == 2 ){// Wenn der Robo nach Norden,Osten,Westen
																			 //schaut dann setze seinen Blick nach Süden.
		setDirection(3);
		
		}else;
		
		
		step();
		
		
		
		
		System.out.println(getDirection());
		
		
		System.out.println(r.getRechteck());
		
		
		
		
	}

}
```



Meine Rechteck Klasse 

```
/*   Klasse zur Erzeugung von Rechteck 
 * 
 *   -----------------------------
 *  |						     |
*   |                            |
 *  |                            |
 *  ------------------------------
 * 
 */

public final class Rechteck {
	// Koordinaten für den Punkt x_1 , y_1   
	private static int x_1;
	private static int y_1;
	
	// Koordinaten für den Punkt x_2 , y_2   
	private static int x_2;
	private static int y_2;
	
	// Koordinaten für den Punkt x_3 , y_3  
	private static int x_3;
	private static int y_3;
	
	// Koordinaten für den Punkt x_4 , y_4  
	private static int x_4;
	private static int y_4;



	 public Rechteck( int x_1 , int y_1 , int x_2 , int y_2 , int x_3 , int y_3 , int x_4, int y_4){
		 
		this.x_1 = x_1;
		this.y_1 = y_1;
		
		this.x_2 = x_2;
		this.y_2 = y_2;
		
		this.x_3 = x_3;
		this.y_3 = y_3;
		 
		this.x_4 = x_4;
		this.y_4 = y_4;
		 
		 
	 }



	// Alle GetterMethoden. 
	 
	 
	public int getX_1() {
		return x_1;
	}



	public int getY_1() {
		return y_1;
	}



	public int getX_2() {
		return x_2;
	}



	public int getY_2() {
		return y_2;
	}



	public int getX_3() {
		return x_3;
	}



	public int getY_3() {
		return y_3;
	}



	public int getX_4() {
		return x_4;
	}



	public int getY_4() {
		return y_4;
	}


   public static String getRechteck(){
	   
	   return "x_1 Position :"+x_1+" y_1 Position :"+y_1+" x_2 Position :"+x_2+" y_2 Position :"+y_2+" x_3 Position :"
	   +x_3+" y_3 Position :"+y_3+" x_4 Position :"+x_4+" y_4 Position :"+y_4;
	   
   }
	
	
	



}
```


Die Klasse zur Erzeugung eines Roboters habe ich mal ausgelassen , da zuviel Code

Kann mir jemand bitte helfen und hat einen Tip?


----------



## Firephoenix (9. Apr 2011)

Hi,
wenn ich das richtig sehe hat der Roboter eine direction und eine step-methode um ein Feld in die Richtung zu laufen?
Damit kann man doch schonmal arbeiten ^^

Dann zu dem Rechteck:
wenn ich dein Rechteck so erzeuge:

```
new Rechteck(0,0,1,1,0,1,999,999);
```
Dann sind das zwar vier Punkte aber mit sicherheit kein Rechteck 

Ein Rechteck kannst du bereits durch zwei gegenüberliegende Punkte aufspannen, die anderen 2 Eckpunkte lassen sich durch Kombination der ersten zwei Punkte ermitteln (falls das nicht einleuchtend ist -> kästchenpapier und Stift -> 2 Punkte einzeichnen -> das passende Rechteck einmalen -> überlegen was man gemacht hat -> in Java schreiben).

Hilfreich wären auch bessere Infos über den Roboter.
Was für Methoden kann man da benutzen? Gibt es eine Koordinatenabfrage?

Falls ja (Pseudoablauf):
-starte z.b. in der unteren rechten Ecke, schaue nach Norden
-Solange du die Koordinaten der oberen Rechten Ecke nicht erreicht hast fahre los
-Wenn du die Ecke erreicht hast drehe dich nach Links und fahre weiter zur nächsten ecke
-usw äquivalent dazu die anderen Ecken.
Gruß


----------



## Leno (9. Apr 2011)

hier ist die eigentliche Java Klasse 


```
public abstract class Roboter
{
   /* Konstanten fuer die Bewegungsrichtungen */

   public static final int OSTEN = 0;
   public static final int NORDEN = 1;
   public static final int WESTEN = 2;
   public static final int SUEDEN = 3;

   /* Klassenvariablen */

   private static int      anzahl = 0;	// Anzahl erzeugte Roboter

   /* Bezeichnungen fuer die Bewegungsrichtungen,
      werden nur fuer die Vereinfachung der Klartextausgabe benutzt */

   private static String[] rname = { "Osten", "Norden", "Westen", "Sueden" };

   /* Aenderung von x- und y- Werten beim Ausfuehren eines Schrittes in
      Bewegungsrichtung
   */
   private static int[]    xdelta = { 1, 0, -1, 0 };
   private static int[]    ydelta = { 0, 1, 0, -1 };

   /* Instanzvariablen */

   private int id;		// Identifikation eines Roboters
   private int x = 0;		// aktuelle X-Position
   private int y = 0;		// aktuelle Y-Position
   private int richtung = OSTEN;// aktuelle Bewegungsrichtung

   /* Klassenmethoden */

   /**
    * Liefert die Anzahl der bisher erzeugten Roboter dieser Klasse.
    * @return Anzahl der bisher erzeugten Roboter
    */
   public static int countRoboter()
   {
      return anzahl;
   }

   /* Aufgabenstellung 3_1 Abstrakte Methode.*/
   
   public abstract void move(); // Abstrakte Methiden immer ohne Methodenrumpf.
   
   
   
   
   
   /* Konstruktoren */

   /**
    * Standard-Konstruktor.
    * Position ist (0,0), Bewegunsgrichtung ist nach Osten
    */
   public Roboter()
   {
      this.setId();	// automatisches setzen der Identifikation
   }

   /**
    * Konstruktor mit definierbarer Position und Richtung.
    *
    * @param x x-Position
    * @param y y-Position
    * @param richtung Bewegungsrichtung
    */
   public Roboter( int x, int y, int richtung )
   {
      /* Initialisierung der Position */

      this.x = x;
      this.y = y;

      /* Dafuer sorgen, dass der Wert fuer die Bewegunsgrichtung immer
         zwischen 0 und 3 liegt.
      */

      this.richtung = richtung % 4;
      if ( this.richtung < 0 )
         this.richtung *= -1;

      this.setId();	// automatisches setzen der Identifikation
   }

   /* Instanzmethoden */

   private void setId()		// setzt die Identifikation fuer einen Roboter
   {
      id = anzahl;		// Identifikation zuweisen und
      anzahl++;			// Anzahl der bisher erzeugten Roboter erhoehen.
   }

   /**
    * Liefert die eindeutige Kennung eines Roboters.
    * @return Identifikation des Roboters
    */
   public int getId()
   {
      return id;
   }

   /**
    * Ermittlung der aktuellen X-Position.
    * @return X-Position des Roboters
    */
   public int getX()
   {
      return x;
   }

   /**
    * Ermittlung der aktuellen Y-Position.
    * @return aktuelle Y-Position des Roboters
    */
   public int getY()
   {
      return y;
   }

   /**
    * Ermittlung der aktuellen Richtung eines Roboters.
    * @return aktuelle Bewegungsrichtung des Roboters
    */
   public int getDirection()
   {
      return richtung;
   }
   
   // Ergänzung für den Waechter_Robotor.
   public void setDirection(int richtung)
   {
      this.richtung = richtung;
   }
   
   
   

   public String getDirectionAsString()
   {
      return rname[richtung];
   }

   /**
    * Ausfuehren eines Schrittes der Laenge 1 in Bewegungsrichtung.
    */
   public void step()
   {
      x += xdelta[ richtung ];
      y += ydelta[ richtung ];
   }

   /** 
    * Drehung nach links.
    */
   public void turnLeft()
   {
      richtung = (richtung + 1) % 4;
   }


   /** 
    * Drehung nach rechts (entspricht dreifacher Drehung nach links).
    */
   public void turnRight()
   {
      richtung = (richtung + 3) % 4;
   }


   /**
    * Ausgabe des Zustandes eines Roboters.
    */
   public void print()
   {
      System.out.println( "Roboter " + id + ": (" + x + ", " + y + ") " + rname[ richtung ] );
   }
}
```


achso das Rechteck ist nicht ganz richtig, ich dachte man könnte das so erzeugen mit 4 Punkten (x,y) in einem Koordinatensystem.


----------



## Firephoenix (9. Apr 2011)

Hi,
mit der Klasse kann man doch gut arbeiten 
Am besten korrigierst du erstmal die Rechteck-Klasse entsprechend auf 2 Punkte die das Rechteck aus 4 Punkten aufspannen.
Für das Rechteck kannst du dir ja eigene getter für die jeweiligen Eckpunkte schreiben.
Dem eigenen Roboter könnte man im Konstruktor dann evtl noch die Parameter für das Rechteck übergeben, falls die Rechtecke nicht bei allen erstellten Robotern gleich sein sollen.
Dannach überschreibst du die Move wieder entsprechend und zeigst mal deinen Ansatz für das Bewegen im Viereck 
Gruß


----------



## Leno (9. Apr 2011)

Sorry verstehe das mit dem Aufspannen nicht so. Also ich lege nur zwei Pukte fest also x und y. In einem Koordinatensytem wird ein Punkt mit x und y markiert und weil wir ja hier punkte haben, dachte ich das wir auch mehrere x und y koordinaten brauchen.
Oder was versteh ich da falsch ?


----------



## Marco13 (9. Apr 2011)

Btw: Die ganzen Variablen
private static int x_1;
...
in Rechteck sollen NICHT static sein! (Und dass Variablennamen keinen "_" Unterstrich enthalten sollten könnte man auch noch erwähnen)


----------



## Firephoenix (10. Apr 2011)

Leno hat gesagt.:


> Sorry verstehe das mit dem Aufspannen nicht so. Also ich lege nur zwei Pukte fest also x und y. In einem Koordinatensytem wird ein Punkt mit x und y markiert und weil wir ja hier punkte haben, dachte ich das wir auch mehrere x und y koordinaten brauchen.
> Oder was versteh ich da falsch ?



Hier, so meinte ich das:
http://www.java-forum.org/attachment.php?attachmentid=2691&stc=1&d=1302466524
Kennst du x und y -Koordinaten der Punkte x1 und x2 ergeben sich daraus automatisch x3 und x4.
x3 hätte z.b. den y-Wert von x1 und den x-Wert von x2.
Damit hast du dann auch sicher ein Rechteck und nicht irgendwas anderes, ein Trapez oder sowas.
Gruß


----------

