import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.io.*;
import java.lang.System;
import java.util.Vector;
import javax.swing.filechooser.FileFilter;


/**
 * <p>Title: Feldagenten GUI </p>
 * <p>Description: Zeigt ein Spielfeld für die Simulation an. Zusätzlich kann ein Spielfels manuell oder automatisch generiert werden.
 * Es gibt unterschiedliche Landschafts- und
 * Feldtypen, sowie hinterlegte Feldeigenschaften wie Metallwert und Bilder.  Auf Feldern können Minen verlegt werden,
 * die später von den Robotern gefunden werden müssen. </p>
 * <p>Copyright:  Kolja Sauerberg, Christian Sonnenberg (c) 2003</p>
 * <p>Company: Student</p>
 * @author Kolja Sauerberg
 * @version 1.1
 */
public class feld {
 // FELDVARIABLEN FESTLEGEN
 //von Christian
 //ATTRIBUTE referencing the FieldAgent
 //is set via constructor
 private FieldAgent myFieldAgent;
 // Deklaration: Frame
 private JFrame frame; //= new JFrame();
 private WindowListener wl = new WindowAdapter() {
   public void windowClosing( WindowEvent e)
      {myFieldAgent.doDelete(); }
 };
  Image startbild;JButton butStartBild;
  Container f;
  JPanel jPanel1 = new JPanel();
  JPanel jPanel2 = new JPanel();
  JScrollPane jPanel3 = new JScrollPane();
  JPanel jPanel4 = new JPanel();
  JButton butStart = new JButton();
  JTextField txtX = new JTextField();
  JTextField txtY = new JTextField();
  JLabel labTxtX = new JLabel();
  JLabel labTxtY = new JLabel();
  JButton test = new JButton();
  JButton obj_ir = new JButton();
  private JButton buttonArray[][];
  private boolean isCreated;
  // Deklaration: Objektinfos
  private JLabel obj_Pos = new JLabel();
  private JLabel obj_PosXY = new JLabel();
  private JLabel obj_metall = new JLabel();
  private JLabel obj_metallWert = new JLabel();
  private JLabel obj_feldTyp = new JLabel();
  private JLabel obj_feldTypWert = new JLabel();
  private JLabel obj_hoehe = new JLabel();
  private JLabel obj_hoeheWert = new JLabel();
  private JLabel obj_landschaft = new JLabel();
  private JLabel obj_landschaftWert = new JLabel();
  private JLabel obj_mine = new JLabel();
  private JLabel obj_mineWert = new JLabel();
  private JButton obj_img = new JButton();
  //Deklaration: Objektarray
  private feldObjekt objektArray[][];
  private Icon imgIcon;
  //Deklaration: Kartentyp
  JComboBox landschaft = new JComboBox();
  JCheckBox huegel = new JCheckBox();
  JCheckBox fluss = new JCheckBox();
  JCheckBox hindernis = new JCheckBox();
  String land[] = {"Grasland" , "Wueste"};
  String feldtypA[] = {"Boden" , "Feldweg" , "Bruecke" , "Asphalt" , "Fluss" , "Hindernis"};
  String minenartA[] = {"Keine" ,"Mine" };
  String hoehenstufeA[] = {"1" , "2" , "3", "4", "5", "6", "7", "8"};
  String metallA[] = {"Kein Ausschlag" , "Ausschlag"};
  // Deklaration : Landschaftsarray
  private boolean landArray[][];
  // Deklaration: MenuBar
  JMenuBar mb = new JMenuBar();
  JScrollPane scroll = new JScrollPane();
  JPanel horizontalPanel = new JPanel();
  JPanel vertikalPanel = new JPanel();
  JLabel horizontalLabel[];
  JLabel vertikalLabel = new JLabel();
  JLabel horizontalLabelX = new JLabel();
  Vector robots = new Vector();
  JList  alleRoboter = new JList();
  JTextField roboterKlasse = new JTextField();
  JTextField roboterName = new JTextField();
  JProgressBar status = new JProgressBar(0,100);
  //für die Bildervorschau ein Registerpanel
  JTabbedPane thumbVorschau = new JTabbedPane();
  // für die manuelle Kartenerstellung gebraucht
  JLabel ueberschrift = new JLabel();
  private boolean istManuellErstellt = false;
  JComboBox landschaftDD = new JComboBox();
  JComboBox metallDD = new JComboBox();
  JToggleButton einMalein = new JToggleButton();
  JToggleButton zweiMalzwei = new JToggleButton();
  JToggleButton dreiMaldrei = new JToggleButton();
  JToggleButton vierMalvier = new JToggleButton();
  JToggleButton achtMalacht = new JToggleButton();
  JToggleButton NbeinMalein = new JToggleButton();
  JToggleButton NbzweiMalzwei = new JToggleButton();
  JToggleButton NbdreiMaldrei = new JToggleButton();
  JToggleButton NbvierMalvier = new JToggleButton();
  JToggleButton NbachtMalacht = new JToggleButton();
  JCheckBox jCheckBox1 = new JCheckBox();
  JCheckBox jCheckBox2 = new JCheckBox();
  JCheckBox jCheckBox3 = new JCheckBox();
  JCheckBox jCheckBox4 = new JCheckBox();
  JTabbedPane manuellTab = new JTabbedPane();
  JList bildauswahl = new JList();
  JButton thumb = new JButton();
  JComboBox feldtypDD = new JComboBox();
  JComboBox feldtypDDNb = new JComboBox();
  JComboBox minenartDD = new JComboBox();
  JComboBox minenartDDNb = new JComboBox();
  JCheckBox metallauschlag = new JCheckBox();
  JComboBox hoeheDD = new JComboBox();
  JComboBox hoeheDDNb = new JComboBox();
  JCheckBox bildauswahlRandom = new JCheckBox("Bilder zufällig zuweisen");
  final JToggleButton minenAufdecken = new JToggleButton();
  final JToggleButton allesAufdecken = new JToggleButton();
  boolean aktion = false;
  int anzahlX=0;
  int anzahlY=0;
  JButton zoomOut = new JButton();
  JButton zoomIn = new JButton();
  JTabbedPane optionen = new JTabbedPane();
  JSlider anzahlHuegel = new JSlider(JSlider.HORIZONTAL,0,100,50);
  JSlider breiteFluss = new JSlider(JSlider.HORIZONTAL,0,100,50);
  JSlider anzahlHindernisse = new JSlider(JSlider.HORIZONTAL,0,100,50);
  ImageIcon mine = new ImageIcon("Icons/mine.gif");
  ImageIcon imgBoden = new ImageIcon("Icons/boden.gif");
  ImageIcon imgFluss = new ImageIcon("Icons/fluss.gif");
  // JPanels für die manuelle Kartenerstellung
  JPanel manuell = new JPanel();
  JPanel manuellObenLinks = new JPanel();
  JPanel groesseEintragen = new JPanel();
  // Konstanten für Himmelsrichtungen
  public static int NORTH = 1;
  public static int NORTHEAST = 2;
  public static int EAST = 3;
  public static int SOUTHEAST = 4;
  public static int SOUTH = 5;
  public static int SOUTHWEST = 6;
  public static int WEST = 7;
  public static int NORTHWEST = 8;
  //constructor is passing a reference to the FieldAgent

  /**
   * Konstruktor zur Erzeugung eines Feldes.
   * Es wird ein Objekt vom Typ FieldAgent übergeben, da das GUI
   * auf dem Feldagenten aufsetzt.
   * @param agent FieldAgent
   */
  public feld(FieldAgent agent) {
    try {
      startbild = new ImageIcon("Bilder/01.jpg").getImage();
      isCreated = false;
      for (int i = 0; i < land.length; i++) {
       landschaft.addItem( land[i] );
      }
      myFieldAgent = agent;
      frameErstellen();
      jbInit();
    }
    catch(Exception e) {
      e.printStackTrace();
    }
  }
  /**
   * erstellt einen Frame
   */
  public void frameErstellen() {
    //Make sure we have nice window decorations.
      JFrame.setDefaultLookAndFeelDecorated(true);
      frame = new JFrame("Simulationsumgebung");
      f =  frame.getContentPane();
      frame.addWindowListener( wl );
      frame.setSize(800,620);
      f.setBackground(SystemColor.textHighlightText);
  }

  /**
   * Initialisiert die Panels und andere Komponenten,
   * die später gebraucht werden.
   * Das Startbild wird am Anfang angezeigt.
   */
  public void jbInit() {
    frame.getContentPane().setBackground(SystemColor.control);
    frame.setEnabled(true);
    frame.setLocale(java.util.Locale.getDefault());
    frame.getContentPane().setLayout(null);
    // Legt die Eigenschaften des Scrollpanels fest
    scroll.setBounds(new Rectangle(0, 30, 500, 500));
    scroll.getViewport().setLayout(null);
    scroll.setViewportBorder( BorderFactory.createLineBorder(Color.black) );
    jPanel1.setBackground(new Color(204,204,255) );
    jPanel1.setBounds(new Rectangle(500, 250, 300, 280));
    this.objektInformationInitialisieren();
    jPanel2.setBackground(new Color(204,204,255) );
    jPanel2.setBounds(new Rectangle(0, 0, 500, 30));
    this.loFuellen();
    jPanel3.setBackground(new Color(204,204,255) );
    jPanel3.setPreferredSize(new Dimension(480, 480));
    jPanel3.setBounds(new Rectangle(0,0,480,480));
    jPanel4.setBackground(new Color(204,204,255) );
    kartenOptionen();
    jPanel4.setBounds(new Rectangle(500, 0, 300, 250));
    scroll.getViewport().add(jPanel3, null);
    // Startbildschirm
    butStartBild = new JButton();
    butStartBild.setBounds(0,0,800,600);
    butStartBild.setIcon(new ImageIcon("start.JPG"));
    frame.getContentPane().add(butStartBild, null);
    frame.getContentPane().add(mb, null);
    frame.setJMenuBar(this.createMenuBar() );
    frame.show();
    // alle DropDown-Menüs mit Werten füllen
    for (int i = 0; i < land.length; i++) {
		landschaftDD.addItem( land[i] );
	}
	for (int i = 0; i < feldtypA.length; i++) {
         feldtypDD.addItem( feldtypA[i] );
         feldtypDDNb.addItem( feldtypA[i] );
    }
    for (int i = 0; i < minenartA.length; i++) {
    	minenartDD.addItem( minenartA[i] );
    	minenartDDNb.addItem( minenartA[i] );
    }
    for (int i = 0; i < hoehenstufeA.length; i++) {
       			hoeheDD.addItem( hoehenstufeA[i] );
       			hoeheDDNb.addItem( hoehenstufeA[i] );
    }
    for (int i = 0; i < metallA.length; i++) {
       			metallDD.addItem( metallA[i] );
    }

  }
  /**
   * returns a reference of the frame
   * @return frame Der anzuzeigende JFrame
   */
  public JFrame getFrame() {
  	return frame;
  }
  /**
   * Füllt das Panel links oben, in dem kleine Icons
   * zum Verändern der Karte sind
   */
  private void loFuellen() {
  jPanel2.setLayout(null);
  JButton butManuell = new JButton();
  JButton save = new JButton();
  JButton open = new JButton();
  ImageIcon plus = new ImageIcon("Icons/plus.jpg");
  ImageIcon minus = new ImageIcon("Icons/minus.jpg");
  ImageIcon mine = new ImageIcon("Icons/mineAn.jpg");
  ImageIcon all = new ImageIcon("Icons/all.jpg");
  ImageIcon autoCal = new ImageIcon("Icons/autoCal.jpg");
  ImageIcon saveIc = new ImageIcon("Icons/save.jpg");
  ImageIcon openIc = new ImageIcon("Icons/open.jpg");
  ImageIcon manuellCal = new ImageIcon("Icons/manuell.jpg");
  zoomOut.setBounds(10,10,20,20);
  zoomOut.setIcon(minus);
  zoomOut.setName("kleiner");
  zoomOut.setPreferredSize(new Dimension (20,20));
  zoomOut.addActionListener(new java.awt.event.ActionListener() {
    public void actionPerformed(ActionEvent e) {
      zoom_actionPerformed(e);
    }
  });
  zoomIn.setBounds(35,10,20,20);
  zoomIn.setIcon(plus);
  zoomIn.setPreferredSize(new Dimension(20,20));
  zoomIn.setName("groesser");
  zoomIn.addActionListener(new java.awt.event.ActionListener() {
    public void actionPerformed(ActionEvent e) {
      zoom_actionPerformed(e);
    }
  });
  minenAufdecken.setBounds(60,10,20,20);
  minenAufdecken.setIcon(mine);
  minenAufdecken.setName("mine");
  minenAufdecken.setPreferredSize(new Dimension (20,20));
  minenAufdecken.addActionListener(new java.awt.event.ActionListener() {
    public void actionPerformed(ActionEvent e) {
		if (minenAufdecken.isSelected()) {
		  minenKennzeichnen(true);
		}
		else minenKennzeichnen(false);
    }
  });
  allesAufdecken.setBounds(85,10,20,20);
  allesAufdecken.setIcon(all);
  allesAufdecken.setName("showAll");
  allesAufdecken.setPreferredSize(new Dimension (20,20));
  allesAufdecken.addActionListener(new java.awt.event.ActionListener() {
    public void actionPerformed(ActionEvent e) {
      if (allesAufdecken.isSelected()) {
      	landschaftKennzeichnen(true);
      	minenKennzeichnen(true);
      }
      else {
      	landschaftKennzeichnen(false);
      	minenKennzeichnen(false);
      }
    }
  });
   butStart.setBounds(200,10,40,20);
   butStart.setIcon(autoCal);
   butStart.setToolTipText("Erstellt ein Spielfeld automatisch.");
   butStart.addActionListener(new java.awt.event.ActionListener() {
    public void actionPerformed(ActionEvent e) {
      butStart_actionPerformed(e);
    }
  });

   butManuell.setBounds(240,10,40,20);
   butManuell.setIcon(manuellCal);
   butManuell.setToolTipText("Ein Spielfeld kann manuell erstellt werden.");
   butManuell.addActionListener(new java.awt.event.ActionListener() {
    public void actionPerformed(ActionEvent e) {
      manualField(e);
    }
  });

  save.setBounds(110,10,20,20);
  save.setIcon(saveIc);
  save.setName("Save Map");
  save.setPreferredSize(new Dimension (20,20));
  save.addActionListener(new java.awt.event.ActionListener() {
    public void actionPerformed(ActionEvent e) {
      speichern();
    }
  });

  open.setBounds(135,10,20,20);
  open.setIcon(openIc);
  open.setName("Save Map");
  open.setPreferredSize(new Dimension (20,20));
  open.addActionListener(new java.awt.event.ActionListener() {
    public void actionPerformed(ActionEvent e) {
      laden();
    }
  });
  jPanel2.add(zoomOut);
  jPanel2.add(zoomIn);
  jPanel2.add(minenAufdecken);
  jPanel2.add(allesAufdecken);
  jPanel2.add(save);
  jPanel2.add(open);
  jPanel2.add(butManuell);
   jPanel2.add( this.butStart );
  }

  /**
   * Action "Feld erstellen" gedrückt:
   * Feld mit eingegebenen Koordinaten wird erstellt
   * Das alte Feld wird gelöscht.
   * @param e übergibt den gedrückten JButton
   */
  private void butStart_actionPerformed(ActionEvent e) {
	automaticField(e);
  }

  /**
   * Erstellt ein Feld, das zur Simulöation geeignet ist, d.h.
   * auf Knopfdruck erscheinen die Objektinfos im rechten Panel.
   * @param anzahlX Breite
   * @param anzahlY Höhe
   */
  public void feldErstellen(int anzahlX, int anzahlY) {
     scroll.setName("FELD");
     // erstellt neue Buttons und schreibt sie in ein Array
     //Berechnet die Anzahl edr zu erstellenden Knöpfe
     buttonArray = new JButton[anzahlX][anzahlY];
     String horBeschriftung = "";
     //Berechnet die Größe der Knöpfe
     int knopfGroesse;
     if (anzahlX > 20 || anzahlY > 20) {
       knopfGroesse = 20;
     }
     // Falls eine Spielfeldgröße von weniger als 20 Feldern
     // in jede Richtung ausgewählt wird, so können die Knöpfe
     // größer dargestellt werden
     else {
       if (anzahlX > anzahlY) {
         knopfGroesse = (int) (400 / anzahlX);
       }
       else {
         knopfGroesse = (int) (400 / anzahlY);
       }
     }
     // aktualisiert die Panel im ScrollPane
     jPanel3.setPreferredSize(new Dimension(knopfGroesse * anzahlX, knopfGroesse * anzahlY));
     jPanel3.setBounds(new Rectangle(0,0,knopfGroesse * anzahlX, knopfGroesse * anzahlY));
	 jPanel3.setName("FELD");

      for (int y = 0; y < anzahlY; y++) {
      	status.setValue(status.getValue() +1);
      	status.repaint();
             for (int x = 0; x < anzahlX; x++) {
                 buttonArray[x][y] = new JButton();
                 buttonArray[x][y].setBorder(BorderFactory.createRaisedBevelBorder());
                 buttonArray[x][y].setName("(" + ((int)x+1) + ";" + ((int)y +1) + ")");
                 buttonArray[x][y].addActionListener(new java.awt.event.ActionListener() {
                   public void actionPerformed(ActionEvent e) {

                     jButton1_actionPerformed(e);
                         }
                     });
                     buttonArray[x][y].setBounds(new Rectangle(x*knopfGroesse, y*knopfGroesse, knopfGroesse , knopfGroesse));
                     buttonArray[x][y].setToolTipText(((int) x+1) +","+ ((int)y +1));
                     jPanel3.add(buttonArray[x][y], null);
                     buttonArray[x][y].setForeground( Color.gray );
                     //System.out.println("x:" +x*knopfGroesse + ", y:" +y*knopfGroesse);
             }
     }
     // isCreated = true setzen, damit Feld beim nächsten erstellen vorher gelöscht wird
     isCreated = true;
   }

   /**
    * Aktualisiert für eine bestimmte Kachel die Feldinfos.
    * @param e Der gedrückte JButton.
    */
   void jButton1_actionPerformed(ActionEvent e) {
                JButton temp = new JButton();
                temp = (JButton) e.getSource();
                String x = "";
                String y = "";
                Integer xInt;
                Integer yInt;
                String strHilf = "";
                int semiPos;
                if (temp.getName().equals("Feld 0")) {
                 System.exit(0);
                }
                strHilf = temp.getName();
                //System.out.println(strHilf);
                semiPos = strHilf.indexOf(";");
                //System.out.println(semiPos);
                x = strHilf.substring(1,semiPos);
                y = strHilf.substring(semiPos +1, strHilf.length()-1);
                xInt =  new Integer(x);
                yInt =  new Integer(y);
                this.objektInformationAendern(temp.getName(), objektArray[xInt.intValue() -1 ][yInt.intValue() -1 ].getFeldTyp()  , objektArray[xInt.intValue()-1 ][yInt.intValue() -1].getMetallwert() , objektArray[xInt.intValue()-1 ][yInt.intValue() -1].getMinewert() , objektArray[xInt.intValue() -1 ][yInt.intValue() -1 ].getBild() , objektArray[xInt.intValue() -1 ][yInt.intValue() -1 ].getHoehenstufe() , objektArray[xInt.intValue() -1 ][yInt.intValue() -1 ].getLandschaftstyp() , objektArray[xInt.intValue() -1 ][yInt.intValue() -1 ].getIR() );
                JButton b = (JButton) e.getSource();
      			String s1 = b.getName();
				s1 = s1.substring(1, s1.length()-1);

				int x1 = new Integer (s1.substring(0, s1.indexOf(";"))).intValue() - 1;
				int y1 = new Integer (s1.substring(s1.indexOf(";") +1 , s1.length() )).intValue() - 1;

      			System.out.println(objektArray[x1][y1].getImageLink());
  }

  /**
   * Löscht das alte Buttonfeld
   */
  public void feldLoeschen() {
   jPanel3.removeAll();
   jPanel3.setForeground( Color.WHITE );
   jPanel3.setForeground( new Color(204,204,255));
   minenAufdecken.setSelected(false);
   allesAufdecken.setSelected(false);
  }

  /**
   *  Initialisiert das Panel mit den Objektinformationen
   */
  public void objektInformationInitialisieren() {
    jPanel1.setLayout(null);
    obj_Pos.setText("Position:");
    obj_Pos.setBounds(10,0, 60, 20);
    obj_Pos.setForeground( Color.black );
    obj_PosXY.setText("(...)");
    obj_PosXY.setBounds(75,0, 60, 20);
    obj_PosXY.setForeground( Color.black );

    obj_feldTyp.setText("Feldtyp:");
    obj_feldTyp.setBounds(10,20, 60, 20);
    obj_feldTyp.setForeground( Color.black );
    obj_feldTypWert.setText("(...)");
    obj_feldTypWert.setBounds(75,20, 60, 20);
    obj_feldTypWert.setForeground( Color.black );

    obj_metall.setText("Metall:");
    obj_metall.setBounds(10,40, 60, 20);
    obj_metall.setForeground( Color.black );
    obj_metallWert.setText("(...)");
    obj_metallWert.setBounds(75,40, 60, 20);
    obj_metallWert.setForeground( Color.black );

    obj_mine.setText("Mine:");
    obj_mine.setBounds(10,60, 60, 20);
    obj_mine.setForeground( Color.black );
    obj_mineWert.setText("(...)");
    obj_mineWert.setBounds(75,60, 60, 20);
    obj_mineWert.setForeground( Color.black );

    obj_hoehe.setText("Ebene:");
    obj_hoehe.setBounds(140,0, 70, 20);
    obj_hoehe.setForeground( Color.black );
    obj_hoeheWert.setText("");
    obj_hoeheWert.setBounds(210,0, 70, 20);
    obj_hoeheWert.setForeground( Color.black );

    obj_landschaft.setText("Landschaft:");
    obj_landschaft.setBounds(140,20, 70, 20);
    obj_landschaft.setForeground( Color.black );
    obj_landschaftWert.setText("");
    obj_landschaftWert.setBounds(210,20, 70, 20);
    obj_landschaftWert.setForeground( Color.black );

    // JTabbedPane für die Bilder
    thumbVorschau.setBounds(10,80,160,140);

    // JButton mit Thumbnail
    obj_img.setBounds(0,0, 160, 120);
    obj_img.setForeground( Color.black);
    obj_img.addActionListener(new java.awt.event.ActionListener() {
    	public void actionPerformed(ActionEvent e) {

    	}
  	});

    // JButtons ins Registerpanel einfügen
    thumbVorschau.add("Foto", obj_img);
    thumbVorschau.add("IR", obj_ir);
    jPanel1.add(thumbVorschau);
    jPanel1.add(obj_Pos);
    jPanel1.add(obj_PosXY);
    jPanel1.add(obj_metall);
    jPanel1.add(obj_metallWert);
    jPanel1.add(obj_feldTyp);
    jPanel1.add(obj_feldTypWert);
    jPanel1.add(obj_mine);
    jPanel1.add(obj_mineWert);
    //jPanel1.add(obj_img);
    jPanel1.add(obj_hoehe);
    jPanel1.add(obj_hoeheWert);
    jPanel1.add(obj_landschaft);
    jPanel1.add(obj_landschaftWert);
  }

  /**
   * Ändert das Panel mit den Objektinformationen
   * @param pos Aktuelle x/y-Koordinate
   * @param feldTyp Feldtyp
   * @param metall Metallwert
   * @param mine Mine?
   * @param icon Bild als ImageIcon
   * @param hoehe Höhenstufe
   * @param land Landschaftstyp
   * @param ir Infrarotbild als ImageIcon
   */
  public void objektInformationAendern(String pos, String feldTyp, boolean metall, String mine, ImageIcon icon, int hoehe, String land, ImageIcon ir) {
    obj_PosXY.setText(pos);
    obj_PosXY.setForeground( Color.black );
    obj_feldTypWert.setText( feldTyp );
    obj_feldTypWert.setForeground( Color.black );
    obj_metallWert.setText("" + metall);
    obj_metallWert.setForeground( Color.black );
    obj_hoeheWert.setText(hoehe + "");
    obj_hoeheWert.setForeground( Color.black );
    obj_landschaftWert.setText(land);
    obj_landschaftWert.setForeground( Color.black );
    obj_mineWert.setText(mine);
    obj_mineWert.setForeground( Color.black );
    obj_img.setIcon(icon);
    obj_ir.setIcon(ir);
  }


  /**
   * Erstellt für jedes Feld ein Feldobjekt
   * @param anzahlX Breite
   * @param anzahlY Höhe
   */
  public void objekteErstellen(int anzahlX, int anzahlY) {
   objektArray = new feldObjekt[anzahlX][anzahlY];
   // Array zu markieren von Sonderobjekten
    landArray = new boolean[anzahlX][anzahlY];
    for (int x=0; x< anzahlX; x++) {
      for (int y=0; y < anzahlY; y++) {
        landArray[x][y] = false;
      }
    }
    // eventuell Fluss erstellen, falls ausgewählt
    if (this.fluss.isSelected() ) {
      this.flussErstellen(anzahlX, anzahlY);
    }
    // eventuell Höhenunterschiede einbauen
    if (this.huegel.isSelected() ) {
      this.huegelErstellen(anzahlX, anzahlY);
    }
    // eventuell Hindernisse einbauen, falls ausgewählt
    if (this.hindernis.isSelected() ) {
      this.createObstacles();
    }

    for (int x = 0; x < anzahlX; x++) {
      for (int y = 0; y < anzahlY; y++) {
        if (landArray[x][y]) {
        }  // Flussobjekt ist schon erzeugt
        else {
          objektArray[x][y] = new feldObjekt(land[landschaft.getSelectedIndex()],
                                             "Boden");
        }
      }
    }
  }

  /**
   * Kennzeichnet alle Felder
   */
  public void landschaftKennzeichnen(boolean b) {
    for (int x =0; x < objektArray.length ; x++) {
      for (int y =0; y< objektArray[1].length ; y++) {
		feldMarkieren(x, y,  b);

      }
    }
  }


  //Kennzeichnet alle  Minen
  private void minenKennzeichnen(boolean b) {
  	 for (int x =0; x < objektArray.length ; x++) {
      for (int y =0; y< objektArray[1].length ; y++) {
       		if (objektArray[x][y].getMinewert().equals("Ja")) {
      	   		if (b) {
      	   			buttonArray[x][y].setIcon(mine );
      	   		}
      	   		else buttonArray[x][y].setIcon(new ImageIcon(""));
      		}
      }
     }
  }

  /**
   * Initialisiert das Panel, auf dem Roboter
   * registriert werden können.
   */
  public void kartenOptionen() {
    jPanel4.setLayout(null);
    JPanel opt_alle = new JPanel();
    JPanel opt_roboter = new JPanel();
    JButton addRoboter = new JButton();
    JButton testMove = new JButton();
    JLabel labRobName = new JLabel("Robotername");
    JLabel labRobKlasse = new JLabel("Roboterklasse");
    JScrollPane listeRoboter = new JScrollPane();
    JPanel auflistung = new JPanel();
    JButton removeRobot = new JButton("Roboter entfernen");
    labRobName.setBounds(5,5,100,20);
    labRobKlasse.setBounds(5,25,100,20);
    roboterName.setBounds(105,5,110,20);
    roboterKlasse.setBounds(105,25,110,20);
    addRoboter.setText("Hinzufügen");
    addRoboter.setBounds(115,60,100,20);
    addRoboter.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        addRoboter_actionPerformed(e);
      }
    });
    testMove.setText("Test");
    testMove.setBounds(305,5,80,20);
    testMove.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
       testMove_actionPerformed(e);
      }
    });

    alleRoboter.setBounds(0,0,250,100);
    alleRoboter.setPreferredSize(new Dimension(250,90));
    auflistung.setBounds(0,0,250,100);
    auflistung.setPreferredSize(new Dimension(250,100));
    listeRoboter.setBounds(5,5,250,100);
    listeRoboter.getViewport().add(auflistung);
    auflistung.add(alleRoboter);
    removeRobot.setBounds(120,110,130,20);
    removeRobot.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        String roboterData = alleRoboter.getSelectedValue().toString();

        String name = roboterData.substring(0,
        					roboterData.indexOf("P")-1) ;

        myFieldAgent.GUIderegister(name);//alleRoboter.getSelectedIndex());
      }
    });
    // Roboteroptionen einstellen
    opt_roboter.setLayout(null);
    opt_roboter.setBounds(10,0,280,200);
    opt_roboter.add(labRobKlasse);
    opt_roboter.add(addRoboter);
    opt_roboter.add(labRobName);
    opt_roboter.add(roboterName);
    opt_roboter.add(roboterKlasse);
	optionen.addTab("Roboter hinzufügen", opt_roboter);
    //Roboter hinzufügen
    opt_alle.setLayout(null);
    opt_alle.setBounds(10,0,280,200);
    opt_alle.add(listeRoboter);
    opt_alle.add(removeRobot);
    optionen.setBounds(0,0,280,280);
    optionen.addTab("Alle Roboter", opt_alle);
    optionen.setBounds(10,0,380,200);
    optionen.setBorder(BorderFactory.createRaisedBevelBorder());
    //Registerkarte zum oberen rechten Panel hinzufügen
    jPanel4.add(optionen);
    //Setzt alle Namen des RoboterArray auf ""
   }

   /**
    * Erstellt einen Fluss mit zufälliger Breite.  Da Roboter
    * Flüsse nicht überqueren können, werden noch Brücken ins
    * Spielfeld eingebaut.
    * @param anzahlX Breite
    * @param anzahlY Höhe
    */
   public void flussErstellen(int anzahlX, int anzahlY) {
     int breite = breiteFluss.getValue(); //(int) Math.ceil(Math.random() * 3);
     int PunktY = 0; //(int) Math.ceil( Math.random() * anzahlY);
     int PunktX = (int) Math.ceil( Math.random() * (anzahlX -1));
     int xRichtung = 0;
     int yRichtung = 1;
     int yTemp;
     boolean bruecke;
     int anzahlBruecken = 0;

      do  {
       // Koordinate mit Fluss füllen

       for (int i = 0; i < breite; i++) {
         if ((PunktX + i) < anzahlX && (PunktX + i) >=0) {
             objektArray[PunktX + i][PunktY] = new feldObjekt(land[landschaft.getSelectedIndex()], "Fluss");
             landArray[PunktX + i][PunktY] = true;
         }
       }

       // neuen Punkt berechnen
       if (xRichtung == 0) {
         xRichtung = (int) (Math.ceil(Math.random() * 3)) - 2;
       }
       else if (xRichtung == 1) {
         xRichtung = xRichtung - (int) (Math.ceil(Math.random() * 2));
       }
       else {
         xRichtung = xRichtung + (int) (Math.ceil(Math.random() * 2)) - 1;
       }
       if (yRichtung == 0) {
         yRichtung = (int) (Math.ceil(Math.random() * 2)) - 1;
       }
       else {
         yRichtung = yRichtung - ((int) (Math.ceil(Math.random() * 2)) - 1);
       }

       PunktX = PunktX + xRichtung;
       PunktY = PunktY + yRichtung;
      }
      while (PunktX < anzahlX && PunktX >= 0 && PunktY < anzahlY && PunktY >= 0);


      do {
      // für jeden Fluss muss ein Weg erstellt werden,
      // der den Fluss passierbar macht
      // da der Fluss von oben nach unten fliesst, wird
      // zufällig eine y-Startkoordinate bestimmt, bei der der
      // Weg den Fluss kreuzt
      PunktY = (int) Math.ceil(Math.random() * (anzahlY-1));
      // zu dieser yKoordinate wird die eine x Koordinate gesucht,
      // die den Feldtyp "Fluss" hat
      for (int x = 0; x < anzahlX; x++) {
        if (landArray[x][PunktY]) {
          PunktX = x;
          break;
        }
        if (x == (anzahlX-1)) {
          PunktX = x;
          break;
        }
      }
      // Falls der Fluss nicht von ganz oben nach unten fließt,
      //  so wird weiter nach einer gültigen Koordinate gesucht
      } while(!(landArray[PunktX][PunktY]));

      // an der ermittelten Flusskoordinate wird zuerst eine
      // gerade Brücke erstellt, die 2 Felder breit ist
      // y muss im gültigen Bereich liegen, da eine NULL als
      // Startpunkt der yKoordinate nicht möglich ist
      for (int y = 0; y > -2 ; y--) {

        for (int i = -2; i < breite + 3; i++) {
          // es muss geprüft werden, ob die xKoordinate existiert
          if ( ( (PunktX + i) < anzahlX) && ( (PunktX + i) >= 0)) {
            // Falls für die Koordinaten schon ein Punkt erzeugt wurde,
            // muss nur der Feldtyp geändert werden
            if (landArray[PunktX + i][PunktY + y]) {
              objektArray[PunktX +
                  i][PunktY + y] = new feldObjekt(land[landschaft.getSelectedIndex()],
                                              "Bruecke");
              landArray[PunktX + i][PunktY + y] = true;
            }
            // sonst muss zusätzlich noch ein neues Objekt erzeugt werden
            // und die Koordinate muss als erstellt gekennzeichnet werden
            else {
              objektArray[PunktX +
                  i][PunktY + y] = new feldObjekt(land[landschaft.getSelectedIndex()],
                                              "Bruecke");
              //objektArray[PunktX + i][PunktY + y].setImageLink(land[landschaft.getSelectedIndex()],"Bruecke", false);


              landArray[PunktX + i][PunktY + y] = true;
            }
          }
        }
      }


      // ab hier wird zufällig ein neuer Weg ermittelt
      // zuerst wird der Weg nach links ausgebaut:
      // Ausgangspunkt ist die Koordinate [PunktX - 3][PunktY]
      // Temporär muss die Brücken-Y-Koordinate gespeichert werden, da s
      // während der Wegberechnung überschrieben wird
      yTemp = PunktY;
      yRichtung = 0;  // für zufällige Wegesänderung gebraucht
      for (int x = PunktX-3; x >= 0; x--) {
        // der Weg soll sich zufällig schlängeln
        // Dafür muss zufällig ein neuer y-Wert berechnet werden
        do {
        if (yRichtung == 0) {
          yRichtung = (int) (Math.ceil(Math.random() * 3)) - 2;
        }
        else if (yRichtung == 1) {
          yRichtung = yRichtung - (int) (Math.floor(Math.random() * 2));

        }
        else {
          yRichtung = yRichtung + (int) (Math.floor(Math.random() * 2));

        }

        // Gültigkeit des neuen Punktes prüfen
        } while(!(((yRichtung +PunktY -1) >=0) && ((yRichtung + PunktY) < anzahlY)));
        // der Weg soll 2 Felder breit sein

        for (int y=0; y > -2; y--) {

          objektArray[x][PunktY + y + yRichtung] = new feldObjekt(land[landschaft.
                                                  getSelectedIndex()],
                                                  "Feldweg");
          landArray[x][PunktY + y + yRichtung] = true;
        }
        PunktY = PunktY +yRichtung;
      }


      // Anschließend wir der Weg rechts der Brücke berechnet
      // beginnend bei  [PunktX + breite +4][PunktY]
      yRichtung = 0;
      // Startpunkt ist wieder die Brücke
      PunktY = yTemp;
      for (int x = (PunktX + breite +3); x < anzahlX; x++) {
       // der Weg soll sich zufällig schlängeln
       // Dafür muss zufällig ein neuer y-Wert berechnet werden
       do {
       if (yRichtung == 0) {
         yRichtung = (int) (Math.ceil(Math.random() * 3)) - 2;
       }
       else if (yRichtung == 1) {
         yRichtung = yRichtung - (int) (Math.floor(Math.random() * 2));

       }
       else {
         yRichtung = yRichtung + (int) (Math.floor(Math.random() * 2)) ;

       }
       // Gültigkeit des neuen Punktes prüfen

       } while(!(((yRichtung +PunktY -1) >=0) && ((yRichtung + PunktY) < anzahlY)));
       // der Weg soll 2 Felder breit sein
       for (int y=0; y > -2; y--) {
         objektArray[x][PunktY + y + yRichtung] = new feldObjekt(land[landschaft.
                                                getSelectedIndex()],
                                                 "Feldweg");
         landArray[x][PunktY + y + yRichtung] = true;
       }
       PunktY = PunktY +yRichtung;
     }



    }  // End Function

    /**
     * Erstellt eine zufällige Anzahl von Hügeln
     * verschiedener Höhe
     * @param anzahlX Breite
     * @param anzahlY Höhe
     */
    public void huegelErstellen(int anzahlX, int anzahlY) {
      int startX =0;
      int startY = 0;
      int ende;
      boolean startOK = false;
      int huegelzahl;

      huegelzahl = anzahlHuegel.getValue();
      // zufällig kleine Hügelvierecke erstellen
      for (int i=0; i< (int) Math.ceil(Math.random() * anzahlX * (anzahlX / 5) * anzahlY * huegelzahl); i++) {
        // Gültigen Ausgangspunkt des Hügels festlegen.  Von hier aus wird
        // der Hügel zufällig ausgeweitet
        //while (startOK == false) {
          startX = (int) Math.floor(Math.random() * anzahlX);
          startY = (int) Math.floor(Math.random() * anzahlY);
          //if (landArray[startX][startY] == false) { startOK = true; }
        //}
        int xEnde = (int) Math.ceil(Math.random() * 2);
        int yEnde = (int) Math.ceil(Math.random() * 2);


        // Hügel erstellen mit 1..4 Feldern
        for (int x = 0; x < xEnde; x++) {
          for (int y = 0; y < yEnde; y++) {
            // Sind die Koordinaten gültig?
            if ( (startX + x < anzahlX) && (startY + y < anzahlY)) {
                // falls Feld existiert
                if (landArray[startX + x][startY + y]) {
                  // nur Höhenstuden bei Feldweg und Boden ändern
                  if ( (objektArray[startX + x][startY +
                        y].getFeldTyp().equals("Feldweg")) ||
                       (objektArray[startX + x][startY +
                        y].getFeldTyp().equals("Boden"))) {
                    objektArray[startX + x][startY +
                        y].setHoehenstufe(objektArray[startX + x][startY +
                                          y].getHoehenstufe()+1);

                  }
                }
                // Feld existiert noch nicht, ist also normaler Boden
                else  {
                  objektArray[startX + x][startY +
                      y] = new feldObjekt(land[landschaft.
                                      getSelectedIndex()],
                                      "Boden");
              // Höhenstufe auf 2 setzen, da 1 Ausgangspunkts ist
              objektArray[startX + x][startY + y].setHoehenstufe(2);
              // Feld als erstellt markieren
              landArray[startX + x][startY + y] = true;
              }
            }

          }
        }
      }


    }


	//Stoesst Registrierungsprozess eines neuen Roboters (aus dem
	//FieldAgent heraus) an
	public void registerRobot(final String robotName) {
		Runnable addIt = new Runnable() {
			public void run() {
				addRobot(robotName, 1, 1);
			}
		};
		SwingUtilities.invokeLater(addIt);
	}

    /**
     * Registriert einen neuen Roboter und setzt ein Icon ins Spielfeld
     * @param x x-Koordinate
     * @param y y-Koordinate
     */
    public void addRobot(String name, int x, int y) {
      String inListe[];

      x = x-1; y = y-1;
	  	
      
      if  ( (movePossible(x,y)) && (!fieldOccupied(x,y)) )  {
        FieldRobotAttributes neuerRobot = new FieldRobotAttributes(name, x,y);
        robots.add(neuerRobot);
        inListe = new String[robots.size()];

        for (int i = 0; i < robots.size(); i++) {
			FieldRobotAttributes nextRobot = (FieldRobotAttributes) robots.elementAt(i);
			inListe[i] = nextRobot.getName() + " Pos: (" + nextRobot.getX()+1 + ";" + nextRobot.getY()+1 + ")  Blick: " + nextRobot.getViewToString() + " Aktiv: " + nextRobot.getZustand()  ;

        }
        alleRoboter.setListData(inListe);
        buttonArray[x][y].setIcon(new ImageIcon("Icons/pfeil_4.jpg"));
      }
      else { 
      JOptionPane.showMessageDialog(frame, "\nEs existiert bereits ein Roboter auf Feld (1/1)!", "Information!", JOptionPane.INFORMATION_MESSAGE);
      }; //Feld besetzt
    }

    /**
     * Prüft, ob ein Roboter, Hindernis, oder eine Mine auf einem Feld liegt.
     */
     private boolean fieldOccupied(int x, int y) {
     	boolean b = false; boolean zustand = false;
     	int posX; int posY;
     	
     	// Roboter auf Feld?
     	for (int i = 0; i < robots.size(); i++) {
			FieldRobotAttributes nextRobot = (FieldRobotAttributes) robots.elementAt(i);
			posX = nextRobot.getX(); posY = nextRobot.getY(); zustand = nextRobot.getZustand();
			if ( (zustand) && (posX == x) && (posY == y) ){
				//System.out.println("*** Koordinatenvergleich: " + posX + "/" +posY +"  -  " + x + "/" + y);
				b = true;
			}
				
        }
        
        // Hindernis?
        if ( (objektArray[x][y].getFeldTyp().equals("Hindernis")) || (objektArray[x][y].getMine()) ) {
        	b = true;
        }
        return b;	
     }
    
    /**
     * Gibt ein Dialogfenster auf dem Bildschirm aus, welches anezeigt,
     * dass ein vorgeschlagener Robotername bereits existiert
     * @param name Robotername
     */
    public void printRegisterDialog(final String name) {
    	Runnable addIt = new Runnable() {
    		public void run() {
    			JOptionPane.showMessageDialog(frame, "\nRoboter '"+name+"' existiert bereits!", "Warnung!", JOptionPane.INFORMATION_MESSAGE);
    		}
    	};
    	SwingUtilities.invokeLater(addIt);
    }

   /**
    * Gibt die Bewegungsdaten an den SimAgent zurück.
    * Es wird vorher geprüft, ob die Bewegung gültig ist.
    * @param name Roboter, der sich bewegen soll
    * @param nachricht Bewegungsinfos
    * @return Feldinfos vom nächsten Feld
    */
   public String getMoveData(String name, String nachricht) {
    int x = 0;
    int y = 0;
    String data;
    // aktuelle Position des Roboters berechnen
	for (int i = 0; i < robots.size(); i++) {
        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
        if (neuerRobot.getName().equals(name)) {
         //aktuelle Position ermitteln
          x = neuerRobot.getX();
          y = neuerRobot.getY();
        }
    }

	// Schrittlänge auslesen
	int distance =  new Integer(nachricht.substring(0 , nachricht.indexOf(";"))).intValue();

	// Richtung auslesen
	int direction = new Integer(nachricht.substring(nachricht.indexOf(";") +1 , nachricht.length() ) ).intValue();

	// Landschaftstyp in den String schreiben
	data = "&" + objektArray[x][y].getLandschaftstyp();


	for (int i = 0; i < distance ; i++) {
			// Richtung und neue Position berechnenberechnen
			switch (direction) {
		        case 1 :  //NORTH
		          y = y - 1;
		          break;
		        case 2 :  // NORTHEAST
		          y = y - 1;
		          x = x + 1;
		          break;
		        case 3 :  //EAST
		          x = x + 1;
		          break;
		        case 4 :  // SOUTHEAST
		          y = y + 1;
		          x = x + 1;
		          break;
		        case 5 : // SOUTH
		          y = y + 1;
		          break;
		        case 6 :  // SOUTHWEST
		          y = y + 1;
		          x = x - 1;
		          break;
		        case 7 :  //WEST
		          x = x - 1;
		          break;
		        case 8 :  // NORTHWEST
		          y = y - 1;
		          x = x - 1;
		          break;

		        default:
		          System.out.println("Operand nicht gefunden");
		      }
		     // Ist die Bewegung möglich, d.h bewegt sich der Roboter nicht über
		    // das Spielfeld hinaus
		    if ( movePossible(x,y) ) {
		 		boolean noObstacle = true;

				// falls anderer Roboter auf Spielfeld steht: Feldtyp = Hindernis
		 		for (int t =0; t < robots.size(); t++) {
		 			FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(t);
		 			if (! neuerRobot.getName().equals(name)) {
		 				if (neuerRobot.getZustand()) {
		 					noObstacle = (!((x == neuerRobot.getX() ) && (y == neuerRobot.getY())));
		 					if (! (noObstacle)) {
		 						break;
		 					}
		 				}
		 			}
		 		}

		 		//notwendige Objektdaten in den Datenstring schreiben
		 		if (noObstacle) {
		 			data = data + "&" + objektArray[x][y].getFeldTyp();
		 		}
		 		else {
		 			data = data + "&Hindernis";
		 		}
		 		System.out.println("***data: " + data);
				data = data + "&" + objektArray[x][y].getHoehenstufe();
				data = data + "&" + objektArray[x][y].getMine();
		    }
		  }  // end for

		  // Ende des Strings markieren
		  data = data + "&";
    	return data;
	}

   /**
    * Gibt die Feldinfos des aktuellen Feldes eines Robbis zurück.
    * @param name Robotername
    * @return Feldinfos
    */
   public String getFieldData(String name) {
    int x = 0;
    int y = 0;
    String data;
    // aktuelle Position des Roboters ermitteln
	for (int i = 0; i < robots.size(); i++) {
        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
        if (neuerRobot.getName().equals(name)) {
         //aktuelle Position ermitteln
          x = neuerRobot.getX();
          y = neuerRobot.getY();
        }
    }

	// Landschaftstyp in den String schreiben
	data = "&" + objektArray[x][y].getLandschaftstyp();
	// Feldtyp in den String schreiben
	data = data + "&" + objektArray[x][y].getFeldTyp();
	// Höhenstufe in den String schreiben
	data = data + "&" + objektArray[x][y].getHoehenstufe();
	// Minenwert in den String schreiben
	data = data + "&" + objektArray[x][y].getMine();
        // Ende des Strings markieren
	data = data + "&";
    return data;
    }

  /**
   * dreht einen Roboter in eine übergebene Richtung
   * @param robName Robotername
   * @param direction neue Blickrichtung
   */
  public void turn(String robName, String direction) {
  	String inListe[];
  	int currentView = 3;
  	int newView;
  	int anzahl45;
  	int x = -1; int y = -1;
  	newView = new Integer(direction).intValue();
  	// zuerst wird die aktuelle Blickrichtung des Robbis ermittelt
  	// un die neue gesetzt
  	for (int i = 0; i < robots.size(); i++) {
        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
        if (neuerRobot.getName().equals(robName)) {
         //aktuelle Blickrichtung
          currentView = neuerRobot.getView();
          // neue Blickrichtung setzen
          neuerRobot.setView(newView);
          // aktuelle Position ermitteln zum setzen des Icons
          x = neuerRobot.getX(); y = neuerRobot.getY();
          buttonArray[x][y].setIcon(new ImageIcon("Icons/pfeil_"+ neuerRobot.getView() +".jpg"));
        }
    }



    // nun wird das Ergebnis auf dem Bildschirm angezeigt
    // buttonArray[x][y].setIcon(newView + ".jpg");

    // die Roboteranzeig wird aktualisiert
    // Roboterliste aktualisieren
      inListe = new String[robots.size()];
      for (int nr = 0; nr < robots.size(); nr++) {
			FieldRobotAttributes nextRobot = (FieldRobotAttributes) robots.elementAt(nr);
			inListe[nr] = nextRobot.getName() + " Pos: (" + nextRobot.getRealX() + ";" + nextRobot.getRealY() + ")  Blick: " + nextRobot.getViewToString() + " Aktiv: " + nextRobot.getZustand()  ;

       }
       alleRoboter.setListData(inListe);

  }

  /**
   * Prüft für einen Roboter, ob ein Hindernis vor ihm ist.
   * @param robName Robotername
   * @return Hindernis?
   */
  public String touch(String robName) {
  	int x = -1;
  	int y = -1;
  	int currentView = 0;
  	String hinderniss;

  	// aktuelle Position ermitteln
  	for (int i = 0; i < robots.size(); i++) {
        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
        if (neuerRobot.getName().equals(robName)) {
          //aktuelle Blickrichtung
          currentView = neuerRobot.getView();
          // aktuelle Position ermitteln zum setzen des Icons
          x = neuerRobot.getX(); y = neuerRobot.getY();
        }
    }

    // Koordinate vom Feld in Blickrichtung
  	// Richtung und neue Position berechnenberechnen
	switch (currentView) {
        case 1 :  //NORTH
          y = y - 1;
          break;
        case 2 :  // NORTHEAST
          y = y - 1;
          x = x + 1;
          break;
        case 3 :  //EAST
          x = x + 1;
          break;
        case 4 :  // SOUTHEAST
          y = y + 1;
          x = x + 1;
          break;
        case 5 : // SOUTH
          y = y + 1;
          break;
        case 6 :  // SOUTHWEST
          y = y + 1;
          x = x - 1;
          break;
        case 7 :  //WEST
          x = x - 1;
          break;
        case 8 :  // NORTHWEST
          y = y - 1;
          x = x - 1;
          break;

        default:
          System.out.println("Operand nicht gefunden");
      }
      // neue Koordinate im Spielfeld?
      if ( movePossible(x,y) ) {
      	hinderniss = objektArray[x][y].getFeldTyp().equals("Hindernis") +"" ;
      	// gibt es einen anderen Roboter auf dem Spielfeld
      	for (int i = 0; i < robots.size(); i++) {
	        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
	        if ( (neuerRobot.getX() == x)  && (neuerRobot.getY() == y) ) {
				hinderniss = "true";
        	}
    	}
      }
      else {
      	// sonst: Koordinate ist nicht im Spielfeld
      	hinderniss = "true";
      }

  	// gibt es ein Hindernis?
  	return hinderniss;
  }

  /**
   * Prüft für einen Roboter, ob sich ein Fluß vor ihm befindet.
   * @param robName Robotername
   * @return Hindernis?
   */
  public String humidity(String robName) {
  	int x = -1;
  	int y = -1;
  	int currentView = 0;
  	String fluss;

  	// aktuelle Position ermitteln
  	for (int i = 0; i < robots.size(); i++) {
        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
        if (neuerRobot.getName().equals(robName)) {
          //aktuelle Blickrichtung
          currentView = neuerRobot.getView();
          // aktuelle Position ermitteln zum setzen des Icons
          x = neuerRobot.getX(); y = neuerRobot.getY();
        }
    }

    // Koordinate vom Feld in Blickrichtung
  	// Richtung und neue Position berechnenberechnen
	switch (currentView) {
        case 1 :  //NORTH
          y = y - 1;
          break;
        case 2 :  // NORTHEAST
          y = y - 1;
          x = x + 1;
          break;
        case 3 :  //EAST
          x = x + 1;
          break;
        case 4 :  // SOUTHEAST
          y = y + 1;
          x = x + 1;
          break;
        case 5 : // SOUTH
          y = y + 1;
          break;
        case 6 :  // SOUTHWEST
          y = y + 1;
          x = x - 1;
          break;
        case 7 :  //WEST
          x = x - 1;
          break;
        case 8 :  // NORTHWEST
          y = y - 1;
          x = x - 1;
          break;

        default:
          System.out.println("Operand nicht gefunden");
      }
      // neue Koordinate im Spielfeld?
      if ( movePossible(x,y) ) {
      	fluss = objektArray[x][y].getFeldTyp().equals("Fluß") +"" ;
      }
      else {
      	// sonst: Koordinate ist nicht im Spielfeld
      	fluss = "true";
      }

  	// gibt es einen Fluß?
  	return fluss;
  }

  /**
   * gibt den Höhenunterschied zwischen dem aktuellen und dem nächsten Feld in
   * Blickrichung zurück
   * @param robName
   * @return
   */
  public String hoehenunterschied(String robName) {
  	int x = -1;int xAlt = -1;
  	int y = -1;int yAlt = -1;
  	int currentView = 0;
  	int differenz;


  	// aktuelle Position ermitteln
  	for (int i = 0; i < robots.size(); i++) {
        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
        if (neuerRobot.getName().equals(robName)) {
          //aktuelle Blickrichtung
          currentView = neuerRobot.getView();
          // aktuelle Position ermitteln zum setzen des Icons
          x = neuerRobot.getX(); y = neuerRobot.getY();
        }
    }
    xAlt = x; yAlt = y;

        // Koordinate vom Feld in Blickrichtung
  	// Richtung und neue Position berechnenberechnen
	switch (currentView) {
        case 1 :  //NORTH
          y = y - 1;
          break;
        case 2 :  // NORTHEAST
          y = y - 1;
          x = x + 1;
          break;
        case 3 :  //EAST
          x = x + 1;
          break;
        case 4 :  // SOUTHEAST
          y = y + 1;
          x = x + 1;
          break;
        case 5 : // SOUTH
          y = y + 1;
          break;
        case 6 :  // SOUTHWEST
          y = y + 1;
          x = x - 1;
          break;
        case 7 :  //WEST
          x = x - 1;
          break;
        case 8 :  // NORTHWEST
          y = y - 1;
          x = x - 1;
          break;

        default:
          System.out.println("Operand nicht gefunden");
      }

      if ( movePossible(x, y) ) {
      	differenz = objektArray[x][y].getHoehenstufe() - objektArray[xAlt][yAlt].getHoehenstufe() ;
      }
      // Koordinate außerhalb des Spielfeldes
      else {
      	differenz = 0;
      }
    return differenz+"";
  }

    /**
     * Moves a robot to a certain field
     * @param nachricht includes the distance and direction
     * @param name name of the robot
     */
    public void bewegen(String name, String nachricht) {

      String inListe[];
      int xMin; int xMax; int yMin; int yMax;
      int startDirection;
      int distance, direction;
      int i = 0;
      int x = 0;
      int y = 0;
      int xAlt , yAlt;
      int indexSemi = 0;
      boolean isExploded = false;
      //NAME-MOVE;DISTANCE:DIRECTION
      startDirection = nachricht.indexOf(";");
      distance = stringToInt(nachricht.substring(0,startDirection));
      direction = stringToInt(nachricht.substring(startDirection + 1, nachricht.length() ));

      for (i = 0; i < robots.size(); i++) {
        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
        if (neuerRobot.getName().equals(name)) {
         //aktuelle Position ermitteln
          x = neuerRobot.getX();
          y = neuerRobot.getY();
          xAlt =x; yAlt = y;

          switch (direction) {
            case 1 :  //NORTH
              y = y - distance;
              break;
            case 2 :  // NORTHEAST
              y = y - distance;
              x = x + distance;
              break;
            case 3 :  //EAST
              x = x + distance;
              break;
            case 4 :  // SOUTHEAST
              y = y + distance;
              x = x + distance;
              break;
            case 5 : // SOUTH
              y = y + distance;
              break;
            case 6 :  // SOUTHWEST
              y = y + distance;
              x = x - distance;
              break;
            case 7 :  //WEST
              x = x - distance;
              break;
            case 8 :  // NORTHWEST
              y = y - distance;
              x = x - distance;
              break;

            default:
              System.out.println("Operand nicht gefunden");
          }
          // Robbi-Icon auf neue Koordinate setzen
          if (movePossible(x, y)) {
          	// falls Mine auf Feld
          	if (objektArray[x][y].getMinewert().equals("Ja")) {
          	   //buttonArray[x][y].setIcon(new ImageIcon("Bilder/Roboter/2.jpg"));
          	   neuerRobot.setZustand(false);
	           objektArray[x][y].setMine(false);
          	   // !! MINENBILDER IN NORMALE BILDER TAUSCHEN !!!
          	   objektArray[x][y].setImageLink(objektArray[x][y].getLandschaftstyp() ,
          	   								objektArray[x][y].getFeldTyp() ,false);
          	   // Roboter wird deregistriert
          	   
          	   isExploded = true;
          	   // Auf alle gesprengten Kacheln ein Symbol setzen
          	   minenKiller(x,y);		   

          	}
          	else if (objektArray[x][y].getFeldTyp().equals("Fluss") ) {
          	   // Roboter wird derigistriert
          	   myFieldAgent.GUIderegister(name);
          	}        	
          	else {
          	// falls das Feld besetzt ist, soll sich der Roboter nicht bewegen
	           System.out.println(fieldOccupied(x,y));
	           if ( fieldOccupied(x,y) ) {
	           	System.out.println("*** x/y " + x + "/" +y);
	           	buttonArray[xAlt][yAlt].setIcon(new ImageIcon("Icons/pfeil_"+ neuerRobot.getView() +".jpg"));
	           	x = xAlt; y= yAlt;distance =0;
	           }
	           else {
	           	buttonArray[x][y].setIcon(new ImageIcon("Icons/pfeil_"+ neuerRobot.getView() +".jpg"));
	           }
	           // neues Bild generieren

	        }
	         	// neue Position setzen
	         	neuerRobot.setPosition(x,y);

	            // altes Icon von Button löschen und Feldicon laden
	            if  ((distance != 0) && (!isExploded) ) {
		
	            	buttonArray[xAlt][yAlt].setIcon(new ImageIcon(""));
	            	feldMarkieren(xAlt, yAlt, true);
	         	}

          }
          break;
        }
      }


	roboterlisteAktualisieren();
	


    }

	private void roboterlisteAktualisieren() {
	  // Roboterliste aktualisieren
      String inListe[];
      inListe = new String[robots.size()];
      for (int nr = 0; nr < robots.size(); nr++) {
			FieldRobotAttributes nextRobot = (FieldRobotAttributes) robots.elementAt(nr);
			inListe[nr] = nextRobot.getName() + " Pos: (" + nextRobot.getRealX() + ";" + nextRobot.getRealY() + ")  Blick: " + nextRobot.getViewToString() + " Aktiv: " + nextRobot.getZustand()  ;

       }
       alleRoboter.setListData(inListe);	
	}
	
	private void minenKiller(int x, int y) {
     int xMin = x-1; int xMax = x+1;
     int yMin = y-1; int yMax = y+1;
     for (int xL = xMin; xL <= xMax; xL++) {
 		for (int yL = yMin; yL <= yMax; yL++) {
 		 if ( movePossible(xL,yL) ) {
 		  buttonArray[xL][yL].setIcon(new ImageIcon("Bilder/Roboter/2.jpg"));
 		 			
 		  if ( objektArray[xL][yL].getMine() ) {
 		 	//System.out.println("Rekursiver Aufruf");
 		 	objektArray[xL][yL].setMine(false);
      	    objektArray[xL][yL].setImageLink(objektArray[xL][yL].getLandschaftstyp() ,
							objektArray[xL][yL].getFeldTyp() ,false);
 		 	minenKiller(xL,yL);	
 		  }
 		 }
 		  // andere Roboter entfernen
 		  for (int i = 0; i < robots.size(); i++) {
			FieldRobotAttributes delRob = (FieldRobotAttributes) robots.elementAt(i);
			if ( (delRob.getX() ==  xL) && (delRob.getY() == yL) ) {
				System.out.println("***Loeschen: " + delRob.getName() );
				removeRobot(delRob.getName());
				//myFieldAgent.GUIderegister(delRob.getName());
				System.out.println("***Geloescht : " + delRob.getName() );
				roboterlisteAktualisieren();
			}
		 }
 		}
 	}
	}	
	

    /**
     * Wandelt einen Zahlenstring in einen int-Wert um.
     * @param var String
     * @return int-Wert
     */
    public int stringToInt(String var) {
      Integer intWert = new Integer(var);
      return intWert.intValue();
    }

 private void addRoboter_actionPerformed(ActionEvent e) {
   if (isCreated) {
     if ( (! this.roboterName.getText().equals("")) && (!fieldOccupied(0,0)) ) {
       myFieldAgent.startNewRobotAgent(roboterName.getText(), roboterKlasse.getText());
     }
     else { 
      JOptionPane.showMessageDialog(frame, "\nEs existiert bereits ein Roboter auf Feld (1/1)!", "Information!", JOptionPane.INFORMATION_MESSAGE);
     }; //Feld besetzt
   }
 }

 /**
  * Führt einige Testoperationen aus
  * @param e
  */
 private void testMove_actionPerformed(ActionEvent e) {
   try {
     if (aktion) {
       bewegen("HERSE", "5;3");
       //befehlErkennen("HERSE-MOVE;2:4");

     }
     else {
       addRobot("HERSE", 10, 10);
       //this.wait(5000);

     }
     aktion =(aktion == false);
   }
   catch(Exception ex) {
      ex.printStackTrace();
    }
 }
 /**
  * Gibt zurück, ob eine Bewegung möglich ist
  * @param x x-Koordinate
  * @param y y-Koordinate
  * @return
  */
 public boolean movePossible(String name, String nachricht) {
 	int distance = 0;
 	int direction = 0;
 	int x = 0;
 	int y = 0;
 	for (int i =0; i < robots.size(); i++) {
 		FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
 		if (neuerRobot.getName().equals(name)) {
 			x = neuerRobot.getX();
 			y = neuerRobot.getY();
 			break;
 		}
 	}
 	distance = new Integer(nachricht.substring(0,nachricht.indexOf(";"))).intValue();
 	direction = new Integer(nachricht.substring(nachricht.indexOf(";") + 1, nachricht.length())).intValue();
 	switch (direction) {
            case 1 :  //NORTH
              y = y - distance;
              break;
            case 2 :  // NORTHEAST
              y = y - distance;
              x = x + distance;
              break;
            case 3 :  //EAST
              x = x + distance;
              break;
            case 4 :  // SOUTHEAST
              y = y + distance;
              x = x + distance;
              break;
            case 5 : // SOUTH
              y = y + distance;
              break;
            case 6 :  // SOUTHWEST
              y = y + distance;
              x = x - distance;
              break;
            case 7 :  //WEST
              x = x - distance;
              break;
            case 8 :  // NORTHWEST
              y = y - distance;
              x = x - distance;
              break;

            default:
              System.out.println("Operand nicht gefunden");
          }

		
   return ((x < anzahlX) && (x >= 0) && (y  < anzahlY) && (y  >= 0) );
 }
 /**
  * Ermittelt die Arrayposition eines Roboters
  * @param name Robotername
  * @return ID des Roboters
  */
 private int getRoboterID(String name) {
   int i =0;
   for (i = 0 ; i < robots.size(); i++) {
     FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
     if (neuerRobot.getName().equals(name)) {
       break;
     }
   }
   return i;
 }

 /**
  * Zoomfunktionalität
  * @param zoom ZoomIn oder ZoomOut
  */
 private void resize(String zoom) {
   int knopfGroesse = buttonArray[0][0].getWidth();

   if (zoom.equals("kleiner")) {
     knopfGroesse = knopfGroesse - 5;
   }

   // buttons resizen
   for (int y = 0; y < anzahlY; y++) {
          for (int x = 0; x < anzahlX; x++) {
                  buttonArray[x][y].setBounds(new Rectangle(x*knopfGroesse, y*knopfGroesse, knopfGroesse , knopfGroesse));
          }
  }
  // aktualisiert die Panel im ScrollPane


 }
 /**
  * Entspricht einer Lupenfunktion mit ZoomIn und ZoomOut
  * bzw anderen Kartenoptionen, z.B. Minen aufdecken
  * @param e
  */
 private void zoom_actionPerformed(ActionEvent e) {
   int knopfGroesse = buttonArray[0][0].getWidth();
   JButton temp = new JButton();
   temp = (JButton) e.getSource();

   // falls Zoom gewählt ist
   if (temp.getName().equals("kleiner")) {
     if (! (knopfGroesse < 6 ) ) {
       knopfGroesse = knopfGroesse - 5;
     }
   }
   if (temp.getName().equals("groesser")) {
     if (! (knopfGroesse >40) ) {
       knopfGroesse = knopfGroesse + 5;

     }
   }
   if (temp.getName().equals("groesser") || temp.getName().equals("kleiner")) {
     // aktualisiert die Panel im ScrollPane
     jPanel3.setPreferredSize(new Dimension(knopfGroesse * anzahlX,
                                            knopfGroesse * anzahlY));
     jPanel3.setBounds(new Rectangle(0, 0, knopfGroesse * anzahlX,
                                     knopfGroesse * anzahlY));

     // buttons resizen
     for (int y = 0; y < anzahlY; y++) {
       for (int x = 0; x < anzahlX; x++) {
         buttonArray[x][y].setBounds(new Rectangle(x * knopfGroesse,
             y * knopfGroesse, knopfGroesse, knopfGroesse));
       }
     }
   }

 }

 /**
  * Erzeugt Hindernisse
  */
 private void createObstacles() {

 	int haeufigkeit = anzahlHindernisse.getValue();
 	int x;
 	int y;
 	haeufigkeit = haeufigkeit * (int) (anzahlX/10);

 	for (int i = 0; i < haeufigkeit ; i++) {
 		x = (int) (Math.floor(Math.random() * anzahlX));
 		y = (int) (Math.floor(Math.random() * anzahlY));

 		if (! landArray[x][y]) {
 			objektArray[x][y] = new feldObjekt(land[landschaft.
                                      getSelectedIndex()],
                                      "Hindernis");
            landArray[x][y] = true;
 		}
 	}
 }

 /**
  * Erzeugt ein Menü
  * @return Die zu erzeugende JMenuBar
  */
 private JMenuBar createMenuBar() {
   JMenuBar menuBar;
   JMenu menu, submenu;
   JMenuItem createAutomatic,createManual, speichern, laden, nachbearbeiten;
   JRadioButtonMenuItem rbMenuItem;
   JCheckBoxMenuItem cbMenuItem;

   //Create the menu bar.
   menuBar = new JMenuBar();

   //Build the first menu.
   menu = new JMenu("Feldoptionen");
   menu.setMnemonic(KeyEvent.VK_A);
   menu.getAccessibleContext().setAccessibleDescription(
        "The only menu in this program that has menu items");
   menuBar.add(menu);


   //a group of JMenuItems
   createAutomatic = new JMenuItem("Karte automatisch generieren",
                                KeyEvent.VK_T);
   //menuItem.setMnemonic(KeyEvent.VK_T); //used constructor instead
   createAutomatic.setAccelerator(KeyStroke.getKeyStroke(
             KeyEvent.VK_1, ActionEvent.ALT_MASK));
   createAutomatic.getAccessibleContext().setAccessibleDescription(
               "This doesn't really do anything");

    createAutomatic.addActionListener(new java.awt.event.ActionListener() {
         public void actionPerformed(ActionEvent e) {
			automaticField(e);
          }
     });

        //a group of JMenuItems
   createManual = new JMenuItem("Karte manuell erstellen",
                                KeyEvent.VK_T);
   //menuItem.setMnemonic(KeyEvent.VK_T); //used constructor instead
   createManual.setAccelerator(KeyStroke.getKeyStroke(
             KeyEvent.VK_2, ActionEvent.ALT_MASK));
   createManual.getAccessibleContext().setAccessibleDescription(
               "This doesn't really do anything");

    createManual.addActionListener(new java.awt.event.ActionListener() {
         public void actionPerformed(ActionEvent e) {
			manualField(e);
          }
     });

        //a group of JMenuItems
   nachbearbeiten = new JMenuItem("Karte manuell nachbearbeiten",
                                KeyEvent.VK_T);
   //menuItem.setMnemonic(KeyEvent.VK_T); //used constructor instead
   nachbearbeiten.setAccelerator(KeyStroke.getKeyStroke(
             KeyEvent.VK_5, ActionEvent.ALT_MASK));
   nachbearbeiten.getAccessibleContext().setAccessibleDescription(
               "This doesn't really do anything");

    nachbearbeiten.addActionListener(new java.awt.event.ActionListener() {
         public void actionPerformed(ActionEvent e) {
			karteNachbearbeiten();
          }
     });


     //a group of JMenuItems
   speichern = new JMenuItem("Karte speichern unter ...",
                                KeyEvent.VK_T);
   //menuItem.setMnemonic(KeyEvent.VK_T); //used constructor instead
   speichern.setAccelerator(KeyStroke.getKeyStroke(
             KeyEvent.VK_3, ActionEvent.ALT_MASK));
   speichern.getAccessibleContext().setAccessibleDescription(
               "Speichern");

    speichern.addActionListener(new java.awt.event.ActionListener() {
         public void actionPerformed(ActionEvent e) {
			speichern();
          }
     });


       //a group of JMenuItems
   laden = new JMenuItem("Karte laden",
                                KeyEvent.VK_T);
   //menuItem.setMnemonic(KeyEvent.VK_T); //used constructor instead
   laden.setAccelerator(KeyStroke.getKeyStroke(
             KeyEvent.VK_4, ActionEvent.ALT_MASK));
   laden.getAccessibleContext().setAccessibleDescription(
               "Load");

   laden.addActionListener(new java.awt.event.ActionListener() {
         public void actionPerformed(ActionEvent e) {
			laden();
          }
     });


   menu.add(createAutomatic);
   menu.add(createManual);
   menu.add(nachbearbeiten);
   menu.add(speichern);
   menu.add(laden);

   return menuBar;

 }

 // Prüft, ob die Koordinaten im Feld liegen
 private boolean movePossible( int x, int y) {
 	
 	return ((x<anzahlX) && (x >=0) && (y < anzahlY) && (y >=0));
 }

 // Ruft den Dialog: Automatische Felderstellung auf
 private void automaticField(ActionEvent e) {
    JPanel feldgroesse = new JPanel();
  	final JTextField xGroesse = new JTextField();
  	final JTextField yGroesse = new JTextField();
    JLabel information = new JLabel();
    JLabel xInfo = new JLabel();
    JLabel yInfo = new JLabel();
    final JDialog fieldAutomatic = new JDialog(frame,true);
    JButton ok = new JButton();

    ok.setBounds(360,220,120,20);
    ok.setText("Feld erstellen");
    ok.addActionListener(new java.awt.event.ActionListener() {
        public void actionPerformed(ActionEvent e) {
          feldLoeschen();
		  anzahlX = new Integer(xGroesse.getText()).intValue();
		  anzahlY = new Integer(yGroesse.getText()).intValue();
          fieldAutomatic.dispose();
          frame.getContentPane().removeAll();
          frame.getContentPane().repaint();
          // alle üblichen Panel anzeigen
          showGamePanels();
          // Feld erstellen
          feldErstellen(anzahlX, anzahlY);

          // Ein zweites Array mit Objekten füllen
		  objekteErstellen(anzahlX,anzahlY);

        }
     });

    feldgroesse.setBounds(100,100,270,400);
    feldgroesse.setBackground(SystemColor.info);
    //feldgroesse.setBackground( Color.red);
    xGroesse.setBounds(190,50,40,20);
    xGroesse.setText("20");
    yGroesse.setBounds(190,70,40,20);
    yGroesse.setText("20");
    information.setBounds(30,30,400,20);
    information.setText("Bitte hier die Größe des automatisch zu erstellenden Feldes angeben:");
    xInfo.setBounds(30,50,160,20);
    xInfo.setText("Breite");
    yInfo.setBounds(30,70,160,20);
    yInfo.setText("Höhe");

    //frame.getContentPane().add(feldgroesse, 0);

    feldgroesse.setLayout(null);
    feldgroesse.setBorder(BorderFactory.createRaisedBevelBorder());
    feldgroesse.add(xGroesse);
    feldgroesse.add(yGroesse);
    feldgroesse.add(information);
    feldgroesse.add(xInfo);
    feldgroesse.add(yInfo);

    yInfo.setForeground( Color.black );
    //feldgroesse.setBackground( Color.lightGray );

	// Sonstige Landschaftsoptionen festlegen
    landschaft.setBounds( 30,105, 120, 20 );
    landschaft.setBackground(SystemColor.info);
    fluss.setBounds(230, 160, 60, 20);
    fluss.setText("Fluß");
    fluss.setBackground(SystemColor.info);
    huegel.setBounds(230,105,60,20);
    huegel.setText("Hügel");
    huegel.setBackground(SystemColor.info);
    hindernis.setBounds(30,160,80,20);
    hindernis.setText("Hindernis");
    hindernis.setBackground(SystemColor.info);

    anzahlHuegel.setBounds(300,105,100,50);
    anzahlHuegel.setMajorTickSpacing(50);
    anzahlHuegel.setMinorTickSpacing(5);
    anzahlHuegel.setPaintLabels(true);
    anzahlHuegel.setPaintTicks(true);
    anzahlHuegel.setBackground(SystemColor.info);

    breiteFluss.setBounds(300,160,100,50);
    breiteFluss.setMajorTickSpacing(2);
    breiteFluss.setMinorTickSpacing(1);
    breiteFluss.setBackground(SystemColor.info);
    breiteFluss.setMaximum(10);
    breiteFluss.setMinimum(1);
    breiteFluss.setValue(5);
    breiteFluss.setPaintLabels(true);
    breiteFluss.setPaintTicks(true);

    anzahlHindernisse.setBounds(105,160,100,50);
    anzahlHindernisse.setMajorTickSpacing(50);
    anzahlHindernisse.setMinorTickSpacing(5);
    anzahlHindernisse.setPaintLabels(true);
    anzahlHindernisse.setPaintTicks(true);
    anzahlHindernisse.setBackground(SystemColor.info);

    //Kartenoptionen einstellen
    feldgroesse.add(landschaft);
    feldgroesse.add(fluss);
    feldgroesse.add(huegel);
    feldgroesse.add(anzahlHuegel);
    feldgroesse.add(breiteFluss);
    feldgroesse.add(hindernis);
    feldgroesse.add(anzahlHindernisse);
    feldgroesse.add(ok);
    fieldAutomatic.setBounds(100,100,500,300);
    fieldAutomatic.setTitle("Feld automatisch generieren");
    fieldAutomatic.getContentPane().add(feldgroesse, 0);
    fieldAutomatic.show();
 }

 // Löscht einen Roboter aus dem Spielfeld
 public void removeRobot(String name) {
 	String inListe[];
 	String roboterName;
 	int index = 0;


 	//Roboter aus Liste entfernen
 	int ende = alleRoboter.getLastVisibleIndex() ;
    for (int i = 0; i <= ende ; i++) {

        	alleRoboter.setSelectedIndex(i);
        	String r = alleRoboter.getSelectedValue().toString();

			System.out.println("Robbi entfernen: " + r.substring(0, r.lastIndexOf("P")-1));
        	if (r.substring(0, r.lastIndexOf("P")-1).equals(name)) {
        	  index = i;

        	  break;
        	}
    }

	FieldRobotAttributes zuLoeschen = (FieldRobotAttributes) robots.elementAt(index);
	int x = zuLoeschen.getX(); int y = zuLoeschen.getY();
	//myFieldAgent.GUIderegister(name);
	//buttonArray[x][y].setIcon(new ImageIcon(""));
	//System.out.println("Gelöscht: " + name);

 	robots.remove(index);
 	inListe = new String[robots.size()];
 	for (int i = 0; i < robots.size(); i++) {
	   FieldRobotAttributes nextRobot = (FieldRobotAttributes) robots.elementAt(i);
		//inListe[i] = nextRobot.getName() + "-(" + nextRobot.getX() + ";" + nextRobot.getY() + ")";
		inListe[i] = nextRobot.getName() + " Pos: (" + nextRobot.getX()+1 + ";" + nextRobot.getY()+1 + ")  Blick: " + nextRobot.getViewToString() + " Aktiv: " + nextRobot.getZustand()  ;
		
     }
     alleRoboter.setListData(inListe);

     // JADE

 }

 /**
  * Speichert die aktuelle Karte ab
  *
  */

 private void speichern() {
   byte buffer[] = new byte[10000000];
   StringWriter out = new StringWriter();
   File file; FileWriter fw;

   // Prüft, ob eine Karte existiert
   boolean istGueltig = false;
   Component[] p = frame.getContentPane().getComponents();
   for (int i = 0; i < p.length; i++) {
   	  if (p[i].getName() != null) {
   		if (p[i].getName().equals("FELD")) {
   			istGueltig = true;
   		}
   	  }
   	}

	if (istGueltig) {

		   try{
		   	// Datei auswählen, in die gespeichert werden soll

		   	 // Setzt das Programmrootverzeichnis als Startverzeichnis
		   	 File pfad = new File("feld.class");
		     String verzeichnis = pfad.getAbsolutePath().substring(0 , pfad.getAbsolutePath().indexOf("feld.class") )   ;
		     JFileChooser chooser = new JFileChooser(verzeichnis);
		     chooser.setFileSelectionMode(JFileChooser.FILES_ONLY );
		     // filtert nur Textdateien
		     chooser.setFileFilter( new FileFilter() {
		          public boolean accept( File f ) {
		            return f.isDirectory() ||
		                   f.getName().toLowerCase().endsWith(".map");
		          }
		          public String getDescription() {
		            return "Saved Maps";
		          }
		        } );

		     int returnVal = chooser.showSaveDialog(null);

		     if ( returnVal == JFileChooser.APPROVE_OPTION )
		     {
		       if ( chooser.getSelectedFile().getName().endsWith(".map") ) {
		       	file = chooser.getSelectedFile();
		       	 fw = new FileWriter(file.getName());
		       }
		       else	{
		        fw = new FileWriter(chooser.getSelectedFile().getName() + ".map");
		       }

		     System.out.println("Beginne Schreiben in Datei.");
		     // Größe des Spielfelds eintragen
		     fw.write("&"+ anzahlX +"&" + anzahlY);
		     // Landschaftstyp eintragen
		     fw.write("&" + objektArray[0][0].getLandschaftstyp() );

		     // Eigenschaften der Objekte in die Datei speichern
		     for (int x = 0 ; x < anzahlX ; x++) {
		     	for (int y = 0; y < anzahlY ; y++) {
		     		// FeldTyp
		     		fw.write("&" + objektArray[x][y].getFeldTyp() );
		     		// Metallwert
		     		fw.write("&" + objektArray[x][y].getMetallwert() );
		     		// Mine?
		     		fw.write("&" + objektArray[x][y].getMinewert() );
		     		// Höhenstufe
		     		fw.write("&" + objektArray[x][y].getHoehenstufe() );
		     		//  Bildlink

		     		fw.write("&" + objektArray[x][y].getImageLink() );
		     		//  Bildlink
		     		//fw.write("&" + objektArray[x][y].getIR() );
		     	}
		     }

		     fw.write("&");
		     fw.close();

		     }
		      else {
		       System.out.println( "Auswahl abgebrochen" );

		      }


		   }
		   catch (Exception e) { System.out.println(e.toString() );
		   }
	}
 }


 // Lädt eine ausgewählte Map
 private void laden() {

 	byte buffer[] = new byte[10000000];
 	int anfang , ende;
 	String feldtyp, link, landschaft;
 	boolean mine, metall;
 	int hoehe;

 	// lädt alle benötigten Panels
 	frame.getContentPane().removeAll();
 	frame.getContentPane().repaint();
 	showGamePanels();

 	try {
 		// Datei auswählen
 		 File pfad = new File("feld.class");
	     String verzeichnis = pfad.getAbsolutePath().substring(0 , pfad.getAbsolutePath().indexOf("feld.class") )   ;
	     JFileChooser chooser = new JFileChooser(verzeichnis);
	     chooser.setFileSelectionMode(JFileChooser.FILES_ONLY );
	     // filtert nur Textdateien
	     chooser.setFileFilter( new FileFilter() {
	          public boolean accept( File f ) {
	            return f.isDirectory() ||
	                   f.getName().toLowerCase().endsWith(".map");
	          }
	          public String getDescription() {
	            return "Saved Maps";
	          }
	        } );

	     int returnVal = chooser.showOpenDialog(null);

	     if ( returnVal == JFileChooser.APPROVE_OPTION )
	     {




	 	FileInputStream in;
	 	in = new FileInputStream(chooser.getSelectedFile().getName());

	 	int len = in.read( buffer , 0 , 10000000);  // Der Buffer sollte reichen
	 	System.out.println("Länge der Karte: " + len);
	 	String str = new String ( buffer, 0 , len);

	 	// Vorhandene FButtons removen und Starteinstellung vornehmen

	 	// Anzahl der x-Felder ermitteln
	 	anfang = str.indexOf("&") + 1;
	 	ende = str.indexOf("&", anfang);
	 	anzahlX = new Integer(str.substring(anfang, ende)).intValue();
	 	anfang = ende + 1;
	 	ende = str.indexOf("&", anfang);
	 	// Anzahl der y-Felder bestimmen
	 	anzahlY = new Integer(str.substring(anfang , ende)).intValue();

	 	// Landschaftstyp bestimmen
	 	anfang = ende + 1;
	 	ende = str.indexOf("&", anfang);
	 	landschaft = str.substring(anfang, ende);

	 	// Feld erstellen
	 	feldLoeschen();
	 	feldErstellen(anzahlX, anzahlY);


	  // Erstellt für jedes Feld ein Feldobjekt entsprechend der
	  // Daten aus der ausgewählten Datei

	   objektArray = new feldObjekt[anzahlX][anzahlY];

	   for (int x = 0; x < anzahlX; x++) {
	   	for (int y = 0; y < anzahlY ; y++) {
	   			//System.out.println("x: " + x + "   y: " +y);

			   	// Feldtypen bestimmen
			   	anfang = ende + 1;
			 	ende = str.indexOf("&", anfang);
			    feldtyp = str.substring(anfang, ende);


			   	// Metallwert bestimmen
			   	anfang = ende + 1;
			 	ende = str.indexOf("&", anfang);
			   	metall = new Boolean( str.substring(anfang, ende) ).booleanValue();


			    // Mine?
			   	anfang = ende + 1;
			 	ende = str.indexOf("&", anfang);
			   	mine =  new Boolean(str.substring(anfang, ende).equals("Ja")).booleanValue();



			   	// Höhenebene bestimmen
			   	anfang = ende + 1;
			 	ende = str.indexOf("&", anfang);
			   	hoehe = new Integer( str.substring(anfang, ende) ).intValue();


			   	// Bildlink bestimmen
			   	anfang = ende + 1;
			 	ende = str.indexOf("&", anfang);
			   	link = str.substring(anfang, ende);


			   // Feldobjekt erstellen
			   objektArray[x][y] = new feldObjekt(	landschaft,
			   										feldtyp,
			   										metall,
			   										mine,
			   										hoehe,
			   										link);
			   	//if ((x == anzahlX-1) && (y == anzahlY-1)) {

			    //}
		}
	   }

	}

	}
	catch (Exception e) { System.out.println(e.toString() ); }

 }


	// ruft den Dialog:  Karte manuell erstellen auf
	private void manualField (ActionEvent e) {


			JLabel xlab = new JLabel("Breite:");
			JLabel ylab = new JLabel("Höhe:");
			final JTextField xText = new JTextField();
			final JTextField yText = new JTextField();
			JButton feldOk = new JButton("Ok");
			final JDialog fieldManual = new JDialog(frame,true);



		frame.getContentPane().removeAll();
		frame.getContentPane().repaint();
		frame.getContentPane().add(butStartBild, null);


		groesseEintragen.setLayout(null);
		groesseEintragen.setBounds(70,200,150,100);
		  xlab.setBounds(10,10,100,20);
		  ylab.setBounds(10,30,100,20);
		  xText.setBounds(110,10,30,20);
		  xText.setText("30");
		  yText.setBounds(110,30,30,20);
		  yText.setText("30");
		  feldOk.setBounds(90,60,50,20);
		  feldOk.addActionListener(new java.awt.event.ActionListener() {
    		public void actionPerformed(ActionEvent e) {
      			int x = new Integer(xText.getText() ).intValue();
      			int y = new Integer(yText.getText() ).intValue();
      		    fieldManual.dispose();
      		    frame.getContentPane().removeAll();
				frame.getContentPane().repaint();
      			manuelleOptionen(x,y, true);
   			 }
  		   });
		groesseEintragen.add(xlab);
		groesseEintragen.add(ylab);
		groesseEintragen.add(xText);
		groesseEintragen.add(yText);
		groesseEintragen.add(feldOk);


		//frame.getContentPane().add(groesseEintragen, 0);
		groesseEintragen.setBackground( SystemColor.info);






		fieldManual.setBounds(250,200,200,150);
		fieldManual.setTitle("Karte manuell erstellen");
		fieldManual.getContentPane().add(groesseEintragen , 0);
		fieldManual.show();
		//frame.getContentPane().add(fieldManual, 0);




	}

	// manuelle Spielfelderstellung
	private void manuelleOptionen(int x, int y, boolean neu) {
	  frame.getContentPane().removeAll();
      frame.getContentPane().repaint();
	  //********************************
	  	 ueberschrift.setBounds(150,5,200,20);
		ueberschrift.setText("Karte manuell erstellen");
		ueberschrift.setForeground( Color.black);
		manuellObenLinks.setLayout(null);
		manuellObenLinks.setBounds(0,0,500,30);
		manuellObenLinks.setBackground( SystemColor.info);
		manuellObenLinks.add(ueberschrift);


			if (!(neu)) {
				frame.getContentPane().removeAll();
				frame.getContentPane().repaint();
			}

			// Basiswerte setzen, um Fehler zu vermeiden
			frame.getContentPane().add(manuellObenLinks, null);
			if (neu) {
				frame.getContentPane().remove(groesseEintragen);
			}
			frame.getContentPane().add(scroll, 0);



			feldLoeschen();
			feldErstellenZuweisung(x,y);
			if (neu) {
				feldInitialisieren(x , y);
			}
			else {
				landschaftKennzeichnen(true); minenKennzeichnen(true);
			}

	  if (istManuellErstellt) {
	  	// do nothing
	  }
	  else {
	  		// damit beim nächsten Mal nicht erneut alles erstellt wird
	  		istManuellErstellt = true;

		  JPanel allgemein = new JPanel();
		  JLabel ueberschriftAllgemein = new JLabel();
		  JPanel alleKartenoptionen = new JPanel();
		  JLabel jLabel1 = new JLabel();
		  JButton allgemeinZuweisen = new JButton();
		  JPanel minenoptionen = new JPanel();
		  JLabel Feldoptionen = new JLabel();
		  JLabel feldtyp = new JLabel();
		  JLabel hoehenstufe = new JLabel();
		  JLabel mine = new JLabel();
		  JLabel bildlink = new JLabel();
		  JLabel groesseZuweisung = new JLabel();
		  JScrollPane bildlauf = new JScrollPane(bildauswahl);
		  JButton karteBenutzen = new JButton();




		  ImageIcon eins = new ImageIcon("Icons/einMalein.jpg");
	 	  ImageIcon zwei = new ImageIcon("Icons/zweiMalzwei.jpg");
	 	  ImageIcon drei = new ImageIcon("Icons/dreiMaldrei.jpg");
	 	  ImageIcon vier = new ImageIcon("Icons/vierMalvier.jpg");
	 	  ImageIcon acht = new ImageIcon("Icons/achtMalacht.jpg");
			//********************************

		 //Listener initialisieren
		 MouseListener mouseListener = new MouseAdapter() {
	     	public void mouseClicked(MouseEvent e) {
		         if (e.getClickCount() == 1) {
		             int index = bildauswahl.locationToIndex(e.getPoint());
		             bildauswahl_MouseClicked(index +1);
		             System.out.println("Clicked on Item " + index);
		          }
		     }
		 	};
		 bildauswahl.addMouseListener(mouseListener);

//**************RAUSKOPIERT************


			//*********Optionen einfügen
			bildlauf.setBounds(new Rectangle(10, 140, 60, 120));
			thumb.setBounds(new Rectangle(90, 140, 160, 120));
			thumb.setBackground(SystemColor.info);

			alleKartenoptionen.setAlignmentY((float) 0.5);
		    alleKartenoptionen.setBorder(BorderFactory.createRaisedBevelBorder());
		    alleKartenoptionen.setDebugGraphicsOptions(0);
		    alleKartenoptionen.setBounds(new Rectangle(0, 0, 300, 600));
		    alleKartenoptionen.setLayout(null);
		    alleKartenoptionen.setBackground(SystemColor.info);

		    allgemein.setToolTipText("");
		    allgemein.setBackground(SystemColor.info);
		    jLabel1.setFont(new java.awt.Font("SansSerif", 0, 11));
		    jLabel1.setRequestFocusEnabled(true);
		    jLabel1.setText("Landschaftstyp");
		    jLabel1.setBounds(new Rectangle(10, 30, 87, 15));
		    //
		    landschaftDD.setBackground(SystemColor.info);
		    landschaftDD.setFont(new java.awt.Font("SansSerif", 0, 11));



		    allgemeinZuweisen.setBounds(new Rectangle(202, 52, 68, 19));
		    allgemeinZuweisen.setEnabled(true);
		    allgemeinZuweisen.setBorder(BorderFactory.createRaisedBevelBorder());
		    allgemeinZuweisen.setDebugGraphicsOptions(0);
		    allgemeinZuweisen.setBorderPainted(true);
		    allgemeinZuweisen.setContentAreaFilled(true);
		    allgemeinZuweisen.setText("Zuweisen");
		    allgemeinZuweisen.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      zuweisen_actionPerformed(e);
			      getBilderliste(landschaftDD.getSelectedItem().toString());
			    }
			  });

		    minenoptionen.setBorder(BorderFactory.createEtchedBorder());
		    minenoptionen.setBounds(new Rectangle(9, 96, 282, 350));
		    minenoptionen.setLayout(null);

		    Feldoptionen.setFont(new java.awt.Font("Dialog", 1, 12));
		    Feldoptionen.setBorder(BorderFactory.createEtchedBorder());
		    Feldoptionen.setText("Feldoptionen");
		    Feldoptionen.setBounds(new Rectangle(10, 5, 260, 20));
		    feldtyp.setText("Feldtyp");
		    feldtyp.setFont(new java.awt.Font("SansSerif", 0, 11));
		    feldtyp.setBounds(new Rectangle(10, 30, 78, 17));
		    hoehenstufe.setText("Höhenstufe");
		    hoehenstufe.setFont(new java.awt.Font("SansSerif", 0, 11));
		    hoehenstufe.setBounds(new Rectangle(120, 90, 64, 20));
		    mine.setText("Mine");
		    mine.setFont(new java.awt.Font("SansSerif", 0, 11));
		    mine.setBounds(new Rectangle(10, 60, 34, 15));
		    bildlink.setToolTipText("");
		    bildlink.setFont(new java.awt.Font("SansSerif", 0, 11));
		    bildlink.setText("Bild auswählen");
		    bildlink.setBounds(new Rectangle(10, 120, 90, 20));
		    //
		    feldtypDD.setFont(new java.awt.Font("SansSerif", 0, 11));
		    feldtypDD.setBackground(SystemColor.info);
		    feldtypDD.setBounds(new Rectangle(95, 30, 175, 20));

	      	feldtypDD.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      if (feldtypDD.getSelectedItem().toString().equals("Fluss") ) {
			      	minenartDD.setSelectedIndex(0);
			      }

			      getBilderliste(objektArray[0][0].getLandschaftstyp() );
			    }
			  });
		    //
		    hoeheDD.setFont(new java.awt.Font("SansSerif", 0, 11));
		    hoeheDD.setBackground(SystemColor.info);
		    hoeheDD.setBounds(new Rectangle(198, 90, 60, 20));

		    metallauschlag.setFont(new java.awt.Font("SansSerif", 0, 11));
		    metallauschlag.setText("Metallausschlag");
		    metallauschlag.setBounds(new Rectangle(10, 90, 110, 20));
		    metallauschlag.setBackground(SystemColor.info);
		    //
		    minenartDD.setBounds(new Rectangle(95, 60, 175, 20));
		    minenartDD.setFont(new java.awt.Font("SansSerif", 0, 11));
		    minenartDD.setBackground(SystemColor.info);
		    minenartDD.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      if ( (feldtypDD.getSelectedItem().toString().equals("Fluss")) && (! (minenartDD.getSelectedItem().toString().equals("Keine") )) ) {
			      	feldtypDD.setSelectedIndex(0);
			      }

			      getBilderliste(objektArray[0][0].getLandschaftstyp() );
			    }
			  });

		    bildauswahl.setBorder(BorderFactory.createLoweredBevelBorder());
		    bildauswahl.setDoubleBuffered(false);


		    groesseZuweisung.setRequestFocusEnabled(true);
		    groesseZuweisung.setToolTipText("");
		    groesseZuweisung.setText("Zuweisungsgröße");
		    groesseZuweisung.setFont(new java.awt.Font("SansSerif", 0, 11));
		    groesseZuweisung.setBounds(new Rectangle(10, 268, 100, 15));

		    bildauswahlRandom.setBounds(new Rectangle(130, 120, 140, 15));
		    bildauswahlRandom.setFont(new java.awt.Font("SansSerif", 0, 11));
		    bildauswahlRandom.setSelected(true);
		    bildauswahlRandom.setBackground(SystemColor.info);

		    // zu veräöndernde Kartengröße
		    einMalein.setSelected(true);
		    einMalein.setText("");
		    einMalein.setIcon(eins);
		    einMalein.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      kartengroesse_actionPerformed(e);
			    }
			  });
		    einMalein.setBounds(new Rectangle(5, 290, 50, 50));
		    einMalein.setName("1");
		    //einMalein.setForeground(new Color(135, 146, 239));
		    zweiMalzwei.setIcon(zwei);
		    zweiMalzwei.setText("");
		    zweiMalzwei.setName("2");
		    zweiMalzwei.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      kartengroesse_actionPerformed(e);
			    }
			  });
		    zweiMalzwei.setBounds(new Rectangle(60, 290, 50, 50));
		    dreiMaldrei.setIcon(drei);
		    dreiMaldrei.setText("");
		    dreiMaldrei.setName("3");
		    dreiMaldrei.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      kartengroesse_actionPerformed(e);
			    }
			  });
		    dreiMaldrei.setBounds(new Rectangle(115, 290, 50, 50));
		    vierMalvier.setIcon(vier);
		    vierMalvier.setText("");
		    vierMalvier.setName("4");
		    vierMalvier.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      kartengroesse_actionPerformed(e);
			    }
			  });
		    vierMalvier.setBounds(new Rectangle(170, 290, 50, 50));
		    achtMalacht.setIcon(acht);
		    achtMalacht.setBounds(new Rectangle(225, 290, 50, 50));
		    achtMalacht.setName("5");
		    achtMalacht.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      kartengroesse_actionPerformed(e);
			    }
			  });


			bildlauf.getViewport().add(bildauswahl, null);

		    //manuellTab.add(alleKartenoptionen, null);
		    allgemein.setAlignmentY((float) 0.5);
		    allgemein.setBorder(BorderFactory.createEtchedBorder());
		    allgemein.setMaximumSize(new Dimension(32767, 32767));
		    allgemein.setBounds(new Rectangle(9, 9, 300, 79));
		    allgemein.setLayout(null);
		    //
		    landschaftDD.setBounds(new Rectangle(95, 27, 175, 20));
		    ueberschriftAllgemein.setFont(new java.awt.Font("Dialog", 1, 12));
		    ueberschriftAllgemein.setBorder(BorderFactory.createEtchedBorder());
		    ueberschriftAllgemein.setDoubleBuffered(false);
		    ueberschriftAllgemein.setMaximumSize(new Dimension(45, 20));
		    ueberschriftAllgemein.setToolTipText("");
		    ueberschriftAllgemein.setDisplayedMnemonic('0');
		    ueberschriftAllgemein.setLabelFor(allgemein);
		    ueberschriftAllgemein.setText("Allgemeine Landschaftseinstellungen");
		    ueberschriftAllgemein.setBounds(new Rectangle(10, 5, 260, 20));
		    allgemein.add(ueberschriftAllgemein, null);
		    allgemein.add(jLabel1, null);
		    allgemein.add(landschaftDD, null);
		    allgemein.add(allgemeinZuweisen, null);
		    alleKartenoptionen.add(minenoptionen, null);
		    minenoptionen.setBackground(SystemColor.info);
		    minenoptionen.add(Feldoptionen, null);
		    minenoptionen.add(feldtyp, null);
		    minenoptionen.add(feldtypDD, null);
		    minenoptionen.add(minenartDD, null);
		    minenoptionen.add(mine, null);
		    minenoptionen.add(hoeheDD, null);
		    minenoptionen.add(hoehenstufe, null);
		    minenoptionen.add(metallauschlag, null);
		    minenoptionen.add(bildlink, null);
		    minenoptionen.add(bildlauf, null);
		    minenoptionen.add(thumb, null);
		    minenoptionen.add(groesseZuweisung, null);
		    minenoptionen.add(bildauswahlRandom, null);
		    alleKartenoptionen.add(allgemein, null);
		    minenoptionen.add(einMalein, null);
		    minenoptionen.add(zweiMalzwei, null);
		    minenoptionen.add(dreiMaldrei, null);
		    minenoptionen.add(vierMalvier, null);
		    minenoptionen.add(achtMalacht, null);

			// Button hinzufügen, damit Karte weiterverwendet werden kann
			karteBenutzen.setBounds(150,470,130,20);
			karteBenutzen.setText("Karte benutzen");
			karteBenutzen.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      // alle Panels vom Frame entfernen
			      frame.getContentPane().removeAll();
	              frame.getContentPane().repaint();
	              // nun müssen noch die ActionListener für die Knöpfe geändert werden
				  feldLoeschen();
	              feldErstellen(anzahlX, anzahlY);
	              // Spielfeld wird aufgedeckt
	              landschaftKennzeichnen(true);
	              minenKennzeichnen(true);
			      // Karte übernehmen und Spieloptionen anzeigen
			      showGamePanels();
			    }
			  });


			// alles zu den Kartenoptionspanel adden
			alleKartenoptionen.add(allgemein);
			alleKartenoptionen.add(minenoptionen);
			alleKartenoptionen.add(karteBenutzen , null);



			manuellTab.setBounds(500,0,300,530);
			manuellTab.add( "Vorbereitung", alleKartenoptionen);



			//Panel für die Nachbereitung mit Controls füllen
			//Deklaration der Variablen
			JPanel nachbereitung = new JPanel();
		  	JPanel hoehe = new JPanel();
		  	JPanel groesse = new JPanel();
		  	JLabel hoeheAendern = new JLabel();
		  	JLabel groesseUeber = new JLabel();
		  	JPanel feldoptionen = new JPanel();
		  	JLabel lab_feldoptionen = new JLabel();


			// Zuweisung von Eigenschaften
			nachbereitung.setBackground(UIManager.getColor("info"));
	    	nachbereitung.setDebugGraphicsOptions(0);
	    	nachbereitung.setBounds(new Rectangle(20, 0, 300, 530));
	    	nachbereitung.setLayout(null);
	    	nachbereitung.setBackground(SystemColor.info);
	    	hoehe.setBackground(SystemColor.info);
	   	 	hoehe.setBorder(BorderFactory.createEtchedBorder());
	    	hoehe.setDebugGraphicsOptions(0);
	    	hoehe.setBounds(new Rectangle(10, 26, 269, 59));
	    	hoehe.setLayout(null);
	    	groesse.setBackground(SystemColor.info);
	    	groesse.setBorder(BorderFactory.createEtchedBorder());
	    	groesse.setBounds(new Rectangle(5, 400, 280, 90));
	    	groesse.setLayout(null);
	    	hoeheAendern.setFont(new java.awt.Font("SansSerif", 0, 12));
	    	hoeheAendern.setBorder(BorderFactory.createEtchedBorder());
	    	hoeheAendern.setRequestFocusEnabled(true);
	    	hoeheAendern.setLabelFor(hoehe);
	    	hoeheAendern.setText("Höhe ändern");
	    	hoeheAendern.setBounds(new Rectangle(10, 10, 245, 15));
	    	hoeheAendern.setFont(new java.awt.Font("SansSerif", 1, 12));
	    	groesseUeber.setFont(new java.awt.Font("SansSerif", 0, 12));
	    	groesseUeber.setBorder(BorderFactory.createEtchedBorder());
	    	groesseUeber.setLabelFor(groesse);
	    	groesseUeber.setRequestFocusEnabled(true);
	    	groesseUeber.setToolTipText("");
	    	groesseUeber.setVerifyInputWhenFocusTarget(true);
	    	groesseUeber.setText("Zuweisungsgröße:");
	    	groesseUeber.setBounds(new Rectangle(9, 9, 242, 20));
	    	groesseUeber.setFont(new java.awt.Font("SansSerif", 1, 12));
	    	feldoptionen.setLayout(null);
	    	feldoptionen.setBounds(new Rectangle(13, 101, 268, 117));
	    	feldoptionen.setBorder(BorderFactory.createEtchedBorder());
	    	feldoptionen.setBackground(SystemColor.info);
	    	lab_feldoptionen.setText("Feldspezifische Werte setzten");
	    	lab_feldoptionen.setBounds(new Rectangle(10, 7, 244, 20));
	    	lab_feldoptionen.setRequestFocusEnabled(true);
	    	lab_feldoptionen.setToolTipText("");
	    	lab_feldoptionen.setLabelFor(feldoptionen);
	    	lab_feldoptionen.setBorder(BorderFactory.createEtchedBorder());
	    	lab_feldoptionen.setFont(new java.awt.Font("SansSerif", 1, 12));
	    	// Höhenstufen
	    	jCheckBox1.setBackground(SystemColor.info);
	    	jCheckBox1.setRequestFocusEnabled(true);
	    	jCheckBox1.setSelected(true);
	    	jCheckBox1.setSelectedIcon(null);
	    	jCheckBox1.setText("Höhenstufe");
	    	jCheckBox1.setBounds(new Rectangle(10, 30, 120, 20));
	    	jCheckBox1.setFont(new java.awt.Font("SansSerif", 0, 12));
	    	jCheckBox1.setName("1");
	    	jCheckBox1.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      checkboxNachbereitung_actionPerformed(e);
			    }
			  });
	        hoeheDDNb.setFont(new java.awt.Font("SansSerif", 0, 11));
		    hoeheDDNb.setBackground(SystemColor.info);
		    hoeheDDNb.setBounds(new Rectangle(140, 30, 60, 20));

			// Feldtyp
	    	jCheckBox2.setBounds(new Rectangle(10, 30, 120, 20));
	    	jCheckBox2.setText("Feldtyp");
	    	jCheckBox2.setSelectedIcon(null);
	    	jCheckBox2.setRequestFocusEnabled(true);
	    	jCheckBox2.setToolTipText("");
	    	jCheckBox2.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      checkboxNachbereitung_actionPerformed(e);
			    }
			  });
	    	jCheckBox2.setName("2");
	    	jCheckBox2.setFont(new java.awt.Font("SansSerif", 0, 12));
	    	jCheckBox2.setBackground(SystemColor.info);
	        feldtypDDNb.setFont(new java.awt.Font("SansSerif", 0, 11));
		    feldtypDDNb.setBackground(SystemColor.info);
		    feldtypDDNb.setBounds(new Rectangle(140, 30, 100, 20));

	    	// Mine
	    	jCheckBox3.setBackground(SystemColor.info);
	    	jCheckBox3.setToolTipText("");
	    	jCheckBox3.setRequestFocusEnabled(true);
	    	jCheckBox3.setSelectedIcon(null);
	    	jCheckBox3.setText("Mine");
	    	jCheckBox3.setName("3");
	    	jCheckBox3.setBounds(new Rectangle(10, 60, 120, 20));
	    	jCheckBox3.setFont(new java.awt.Font("SansSerif", 0, 12));
	    	jCheckBox3.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      checkboxNachbereitung_actionPerformed(e);
			    }
			  });
	    	minenartDDNb.setBounds(new Rectangle(140, 60, 100, 20));
		    minenartDDNb.setFont(new java.awt.Font("SansSerif", 0, 11));
		    minenartDDNb.setBackground(SystemColor.info);

	    	// Metall
	    	jCheckBox4.setBounds(new Rectangle(10, 90, 120, 20));
	    	jCheckBox4.setText("Metallauschlag");
		    jCheckBox4.setSelectedIcon(null);
		    jCheckBox4.setName("4");
	    	jCheckBox4.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      checkboxNachbereitung_actionPerformed(e);
			    }
			  });
		    jCheckBox4.setRequestFocusEnabled(true);
		    jCheckBox4.setToolTipText("");
		    jCheckBox4.setBackground(SystemColor.info);
		    jCheckBox4.setFont(new java.awt.Font("SansSerif", 0, 12));
		    metallDD.setBounds(new Rectangle(140, 90, 100, 20));
		    metallDD.setFont(new java.awt.Font("SansSerif", 0, 11));
		    metallDD.setBackground(SystemColor.info);

		    // Zuweisungsgröße
		    	    // zu veräöndernde Kartengröße
		    NbeinMalein.setSelected(true);
		    NbeinMalein.setText("");
		    NbeinMalein.setIcon(eins);
		    NbeinMalein.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      kartengroesse_actionPerformed(e);
			    }
			  });
		    NbeinMalein.setBounds(new Rectangle(5, 35, 50, 50));
		    NbeinMalein.setName("1");
		    //einMalein.setForeground(new Color(135, 146, 239));
		    NbzweiMalzwei.setIcon(zwei);
		    NbzweiMalzwei.setText("");
		    NbzweiMalzwei.setName("2");
		    NbzweiMalzwei.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      kartengroesse_actionPerformed(e);
			    }
			  });
		    NbzweiMalzwei.setBounds(new Rectangle(60, 35, 50, 50));
		    NbdreiMaldrei.setIcon(drei);
		    NbdreiMaldrei.setText("");
		    NbdreiMaldrei.setName("3");
		    NbdreiMaldrei.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      kartengroesse_actionPerformed(e);
			    }
			  });
		    NbdreiMaldrei.setBounds(new Rectangle(115, 35, 50, 50));
		    NbvierMalvier.setIcon(vier);
		    NbvierMalvier.setText("");
		    NbvierMalvier.setName("4");
		    NbvierMalvier.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      kartengroesse_actionPerformed(e);
			    }
			  });
		    NbvierMalvier.setBounds(new Rectangle(170, 35, 50, 50));
		    NbachtMalacht.setIcon(acht);
		    NbachtMalacht.setBounds(new Rectangle(225, 35, 50, 50));
		    NbachtMalacht.setName("5");
		    NbachtMalacht.addActionListener(new java.awt.event.ActionListener() {
			    public void actionPerformed(ActionEvent e) {
			      kartengroesse_actionPerformed(e);
			    }
			  });

		    nachbereitung.add(hoehe, null);
		    hoehe.add(hoeheAendern, null);
		    hoehe.add(jCheckBox1, null);
		    hoehe.add(hoeheDDNb , null);
		    nachbereitung.add(groesse, null);
		    groesse.add(groesseUeber, null);
		    nachbereitung.add(feldoptionen, null);
		    feldoptionen.add(lab_feldoptionen, null);
		    feldoptionen.add(jCheckBox2, null);
		    feldoptionen.add(jCheckBox4, null);
		    feldoptionen.add(metallDD, null);
		    feldoptionen.add(jCheckBox3, null);
		    feldoptionen.add(feldtypDDNb, null);
		    feldoptionen.add(minenartDDNb, null);
		    groesse.add(NbeinMalein, null);
		    groesse.add(NbzweiMalzwei, null);
		    groesse.add(NbdreiMaldrei, null);
		    groesse.add(NbvierMalvier, null);
		    groesse.add(NbachtMalacht, null);


			// Nachbereitungspanel wird im Tab registriert
			//nachbereitung.setBounds(new Rectangle(0, 0, 300, 530));
			manuellTab.add( "Nachbearbeitung", nachbereitung);

		}
		//manuell.setBounds(500,0,300,530);
		//manuell.add(manuellTab, 0);
		frame.getContentPane().add(manuellTab, 0);
		frame.getContentPane().repaint();
		//manuellTab.setBackground( Color.red);
		//manuellTab.set

		//allgemeinZuweisen.setForeground(Color.black);

		// Bilder in die JList laden
		getBilderliste("Grasland");


	}

 private void checkboxNachbereitung_actionPerformed(ActionEvent e) {

 	JCheckBox aktuell = (JCheckBox) e.getSource();
	boolean selected[] = new boolean[5];

 	System.out.println(aktuell.getName());

 	for (int i = 1; i < 5; i++) {
		if (aktuell.getName().equals(""+i) ) {
			selected[i] = true;
		}
		else {
			selected[i] = false;
		}
	}

	jCheckBox1.setSelected(selected[1]);
	jCheckBox2.setSelected(selected[2]);
	jCheckBox3.setSelected(selected[3]);
	jCheckBox4.setSelected(selected[4]);


 }

  private void feldInitialisieren(int anzahlX, int anzahlY) {
  	this.anzahlX = anzahlX; this.anzahlY = anzahlY;
  	objektArray = new feldObjekt[anzahlX][anzahlY];
  	for (int x = 0; x < anzahlX; x++) {
  		for (int y = 0; y < anzahlY; y++) {
  			objektArray[x][y] = new feldObjekt(landschaftDD.getSelectedItem().toString());
  		}
  	}
  	minenKennzeichnen(true);
  	landschaftKennzeichnen(true);
  }

	private void kartengroesse_actionPerformed(ActionEvent e) {
		JToggleButton aktuell = (JToggleButton) e.getSource();
		boolean selected[] = new boolean[7];

		for (int i = 0; i < 6; i++) {
			if (aktuell.getName().equals(""+i) ) {
				selected[i] = true;
			}
			else {
				selected[i] = false;
			}
		}


		einMalein.setSelected(selected[1]);
		zweiMalzwei.setSelected(selected[2]);
		dreiMaldrei.setSelected(selected[3]);
		vierMalvier.setSelected(selected[4]);
		achtMalacht.setSelected(selected[5]);
		NbeinMalein.setSelected(selected[1]);
		NbzweiMalzwei.setSelected(selected[2]);
		NbdreiMaldrei.setSelected(selected[3]);
		NbvierMalvier.setSelected(selected[4]);
		NbachtMalacht.setSelected(selected[5]);


		//System.out.println( aktuell.getName() );
	}


	// Gibt die Feldgröße zurück
	public String getSize() {
		return anzahlX + ";" + anzahlY;
	}

	private void zuweisen_actionPerformed(ActionEvent e) {
		for(int x = 0; x < anzahlX; x++) {
			for (int y = 0; y < anzahlY; y++) {
				objektArray[x][y].setLandschaftstyp(landschaftDD.getSelectedItem().toString() );
				//ÄNDERN !!!!!!!!!!!!!!!!!!!!!!!!!!1
				objektArray[x][y].setImageLink(landschaftDD.getSelectedItem().toString(),
												"Boden",
												false
												 );
			}
		}
		landschaftKennzeichnen(true);
	}

	private void bildauswahl_MouseClicked(int index) {
		File userdir = new File( System.getProperty("user.dir") );
		String landschaft = landschaftDD.getSelectedItem().toString();

		// Sonderverzeichnisse ev. setzen
	    if (feldtypDD.getSelectedItem().toString().equals("Fluss") ) {
	    	landschaft = landschaft + "/Wasser";
	    }
	    else if (!(minenartDD.getSelectedItem().toString().equals("Keine")) ) {
	    	landschaft = landschaft + "/Mine";
	    }
	    else if (feldtypDD.getSelectedItem().toString().equals("Bruecke") ) {
	    	landschaft = landschaft + "/Bruecke";
	    }
	    else if (feldtypDD.getSelectedItem().toString().equals("Asphalt") ) {
	    	landschaft = landschaft + "/Asphalt";
	    }
	    else if (feldtypDD.getSelectedItem().toString().equals("Feldweg") ) {
	    	landschaft = landschaft + "/Feldweg";
	    }
		thumb.setIcon( new ImageIcon (userdir + "/Bilder/" + landschaft + "/th_" + index + ".jpg") );;
	}

	private void getBilderliste(String pfad) {
	    File userdir = new File( System.getProperty("user.dir") );

	    // Sonderverzeichnisse ev. setzen
	    if (feldtypDD.getSelectedItem().toString().equals("Fluss") ) {
	    	pfad = pfad + "/Wasser";
	    }
	    else if (!(minenartDD.getSelectedItem().toString().equals("Keine")) ) {
	    	pfad = pfad + "/Mine";
	    }
	    else if (feldtypDD.getSelectedItem().toString().equals("Asphalt") ) {
	    	pfad = pfad + "/Asphalt";
	    }
	    else if (feldtypDD.getSelectedItem().toString().equals("Bruecke") ) {
	    	pfad = pfad + "/Bruecke";
	    }
	    else if (feldtypDD.getSelectedItem().toString().equals("Feldweg") ) {
	    	pfad = pfad + "/Wasser";
	    }
	    //if (minenartDD.getSelectedItem().toString().equals("Tretmine") ) {
	    //	pfad = pfad + "/Mine";
	    //}


	    File bilder = new File(userdir + "/Bilder/" + pfad);
		System.out.println( bilder );

	    String entries[] = bilder.list( new TxtFilenameFilter() );
	    for ( int i = 0; i < entries.length; i++ ) {
	      System.out.println( entries[i] );
	     }
	     bildauswahl.setListData(entries);
	     bildauswahl.setSelectedIndex(0);
	  }


	// Erstell ein Feld, Jedem Button können per Klick Feldeigenschaften
	// übergeben werden
  public void feldErstellenZuweisung(int anzahlX, int anzahlY) {


	scroll.setName("FELD");
     // erstellt neue Buttons und schreibt sie in ein Array
     //Berechnet die Anzahl edr zu erstellenden Knöpfe
     buttonArray = new JButton[anzahlX][anzahlY];
     String horBeschriftung = "";

     //Berechnet die Größe der Knöpfe
     int knopfGroesse;
     if (anzahlX > 20 || anzahlY > 20) {
       knopfGroesse = 20;
     }
     // Falls eine Spielfeldgröße von weniger als 20 Feldern
     // in jede Richtung ausgewählt wird, so können die Knöpfe
     // größer dargestellt werden
     else {
       if (anzahlX > anzahlY) {
         knopfGroesse = (int) (400 / anzahlX);
       }
       else {
         knopfGroesse = (int) (400 / anzahlY);
       }
     }
     // aktualisiert die Panel im ScrollPane
     jPanel3.setPreferredSize(new Dimension(knopfGroesse * anzahlX, knopfGroesse * anzahlY));
     jPanel3.setBounds(new Rectangle(0,0,knopfGroesse * anzahlX, knopfGroesse * anzahlY));
	 jPanel3.setName("FELD");
     //horizontalPanel.setLayout(null);

     //horizontalLabel.setText(horBeschriftung);
     //horizontalPanel.add(horizontalLabel);


      for (int y = 0; y < anzahlY; y++) {

             for (int x = 0; x < anzahlX; x++) {
                 buttonArray[x][y] = new JButton();
                 buttonArray[x][y].setBorder(BorderFactory.createRaisedBevelBorder());
                 buttonArray[x][y].setName("(" + ((int)x+1) + ";" + ((int)y +1) + ")");
                 buttonArray[x][y].addActionListener(new java.awt.event.ActionListener() {
                   public void actionPerformed(ActionEvent e) {

                     feldzuweisung_actionPerformed(e);
                         }
                     });
                     buttonArray[x][y].setBounds(new Rectangle(x*knopfGroesse, y*knopfGroesse, knopfGroesse , knopfGroesse));
                     buttonArray[x][y].setToolTipText(((int) x+1) +","+ ((int)y +1));
                     jPanel3.add(buttonArray[x][y], null);
                     buttonArray[x][y].setForeground( Color.gray );
                     //System.out.println("x:" +x*knopfGroesse + ", y:" +y*knopfGroesse);
             }
     }


     // isCreated = true setzen, damit Feld beim nächsten erstellen vorher gelöscht wird
     isCreated = true;

     // Ein zweites Array mit Objekten füllen

     //this.objekteErstellen(anzahlX,anzahlY);




   }

   private void feldzuweisung_actionPerformed(ActionEvent e) {
    JButton temp = new JButton();
    temp = (JButton) e.getSource();
    String s = temp.getName();
	s = s.substring(1, s.length()-1);

	int x = new Integer (s.substring(0, s.indexOf(";"))).intValue() - 1;
	int y = new Integer (s.substring(s.indexOf(";") +1 , s.length() )).intValue() - 1;

	boolean mine = (!(minenartDD.getSelectedItem().toString().equals("Keine")));


   	int ende = 1;
   	if (einMalein.isSelected()) {
		ende = 1;
   	}
   	if (zweiMalzwei.isSelected()) {
		ende = 2;
   	}
   	if (dreiMaldrei.isSelected()) {
		ende = 3;
   	}
   	if (vierMalvier.isSelected()) {
		ende = 4;
   	}
   	if (achtMalacht.isSelected()) {
		ende = 8;
   	}


   	if (manuellTab.getSelectedIndex() == 0) {
	   	String link;
	   	link = "Bilder/" + objektArray[0][0].getLandschaftstyp() + "/";

	   	if (mine) { link = link + "Mine/"; }
	   	else  {
	   		if	( (!(feldtypDD.getSelectedItem().toString().equals("Boden"))) && (!(feldtypDD.getSelectedItem().toString().equals("Hindernis"))) ) {
	   	   	  if	((feldtypDD.getSelectedItem().toString().equals("Fluss"))) {
	   	   	     link = link + "Wasser/";
	   	   	  }
	   	   	  else {
	   	   		link = link + feldtypDD.getSelectedItem().toString() +"/";
	   	   	  }
	   		}
	   	}

	   	link = link + "th_" + bildauswahl.getSelectedValue().toString();



	   	for (int xAdd = 0 ; xAdd < ende; xAdd++) {
	   		  for (int yAdd = 0 ; yAdd < ende; yAdd++) {
	   			if (movePossible(x+xAdd , y+yAdd)) {
	   				if (bildauswahlRandom.isSelected() ) {
	   					objektArray[x + xAdd][y + yAdd] = new feldObjekt( objektArray[0][0].getLandschaftstyp(),
	   										 feldtypDD.getSelectedItem().toString(),
	   										 metallauschlag.isSelected(),
	   										 mine,
	   										 new Integer (hoeheDD.getSelectedItem().toString()).intValue(),
	   										 link);

	   					objektArray[x + xAdd][y + yAdd].setImageLink(landschaftDD.getSelectedItem().toString(),
													feldtypDD.getSelectedItem().toString(),
													(!(minenartDD.getSelectedItem().toString().equals("Keine")))
													 );
	   					/*
	   					link = "Bilder/" + objektArray[0][0].getLandschaftstyp() +"/";
					   	if (mine) { link = link + "Mine/"; }
					   	if (feldtypDD.getSelectedItem().toString().equals("Fluss")) {
					   		link = link + "Wasser/";
					   	}

					 	*/
					 }
					 // Bild manuell hinzufügen
					 else  {
					 	System.out.println("Bildlink: " + link);

	   					objektArray[x + xAdd][y + yAdd] = new feldObjekt( objektArray[0][0].getLandschaftstyp(),
	   										 feldtypDD.getSelectedItem().toString(),
	   										 metallauschlag.isSelected(),
	   										 mine,
	   										 new Integer (hoeheDD.getSelectedItem().toString()).intValue(),
	   										 link);
	   				}
	   				}
	   			}
	   }
  } //end if
  else {


  	//*************
	for (int xAdd = 0 ; xAdd < ende; xAdd++) {
	  for (int yAdd = 0 ; yAdd < ende; yAdd++) {
		if (movePossible(x+xAdd , y+yAdd)) {
		  	if (jCheckBox1.isSelected()) {
  				objektArray[x+xAdd][y+yAdd].setHoehenstufe(new Integer(hoeheDDNb.getSelectedItem().toString()).intValue());
  			}
		  	if (jCheckBox2.isSelected()) {
  				objektArray[x+xAdd][y+yAdd].setFeldTyp(feldtypDDNb.getSelectedItem().toString());
  			}
		  	if (jCheckBox3.isSelected()) {
  				objektArray[x+xAdd][y+yAdd].setMine(!(minenartDDNb.getSelectedItem().toString().equals("Keine")));
  			}
		  	if (jCheckBox4.isSelected()) {
  				objektArray[x+xAdd][y+yAdd].setMetall(metallDD.getSelectedItem().toString().equals("Ausschlag"));
  			}
		}
	}
  	//************

  	}
  }

    landschaftKennzeichnen(true); minenKennzeichnen(true);
   }


   // Zeigt alle Panels an, die zum Spiel gebraucht werden.  Alle Erstellungs-
   // Panels werden ausgeblendet
     public void showGamePanels() {

	    frame.getContentPane().add(jPanel2, null);
	    frame.getContentPane().add(jPanel4, null);
	    //frame.getContentPane().add(jPanel3, null);
	    frame.getContentPane().add(scroll, null);
	    frame.getContentPane().add(jPanel1, null);
	    frame.getContentPane().repaint();

	}


  private void feldMarkieren(int x, int y, boolean b) {
	if (b) {
        if (objektArray[x][y].getLandschaftstyp().equals("Grasland")) {
        	// Setzt einen Hindtergrund für den Boden
        	buttonArray[x][y].setIcon(imgBoden);
          if (objektArray[x][y].getHoehenstufe() == 1) {
            buttonArray[x][y].setBackground(new Color(0,255,0) );
          }
          else if (objektArray[x][y].getHoehenstufe() == 2) {
            buttonArray[x][y].setBackground(new Color(30,200,00)  );
          }
          else if (objektArray[x][y].getHoehenstufe() == 3) {
            buttonArray[x][y].setBackground(new Color(60,170,00)  );
          }
          else if (objektArray[x][y].getHoehenstufe() == 4) {
            buttonArray[x][y].setBackground(new Color(90,140,00)  );
          }
          else if (objektArray[x][y].getHoehenstufe() == 5) {
            buttonArray[x][y].setBackground(new Color(120,110,00)  );
          }
          else if (objektArray[x][y].getHoehenstufe() >= 6) {
            buttonArray[x][y].setBackground(new Color(150,80,00)  );
          }


          else {
            System.out.println(objektArray[x][y].getHoehenstufe());
            buttonArray[x][y].setBackground(new Color(66,99,255)  );
          }
        }
        if (objektArray[x][y].getLandschaftstyp().equals("Wueste")) {
          if (objektArray[x][y].getHoehenstufe() == 1) {
            buttonArray[x][y].setBackground(new Color(255,255,200) );
          }
          else if (objektArray[x][y].getHoehenstufe() == 2) {
            buttonArray[x][y].setBackground(new Color(255,255,160)  );
          }
          else if (objektArray[x][y].getHoehenstufe() == 3) {
            buttonArray[x][y].setBackground(new Color(255,255,120)  );
          }
          else if (objektArray[x][y].getHoehenstufe() == 4) {
            buttonArray[x][y].setBackground(new Color(255,255,80)  );
          }
          else if (objektArray[x][y].getHoehenstufe() == 5) {
            buttonArray[x][y].setBackground(new Color(255,255,40)  );
          }
          else if (objektArray[x][y].getHoehenstufe() >= 6) {
            buttonArray[x][y].setBackground(new Color(255,255,0)  );
          }


          else {
            System.out.println(objektArray[x][y].getHoehenstufe());
            buttonArray[x][y].setBackground(new Color(66,99,255)  );
          }
        }
        if (objektArray[x][y].getFeldTyp().equals("Fluss")) {
          buttonArray[x][y].setIcon(imgFluss);
          buttonArray[x][y].setBackground(new Color(66,99,255) );
        }
        if (objektArray[x][y].getFeldTyp().equals("Bruecke")) {
          buttonArray[x][y].setBackground(new Color(198,155,127) );
        }
        if (objektArray[x][y].getFeldTyp().equals("Asphalt")) {
          buttonArray[x][y].setBackground(Color.black );
        }
        if (objektArray[x][y].getFeldTyp().equals("Feldweg")) {
          buttonArray[x][y].setBackground(Color.lightGray  );
        }


        if (objektArray[x][y].getFeldTyp().equals("Hindernis")) {
          buttonArray[x][y].setIcon(new ImageIcon("Icons/tree.gif"));
        }


	}
	else {
	  buttonArray[x][y].setIcon(new ImageIcon(""));
	  buttonArray[x][y].setBackground( Color.lightGray);
	}


  }

  // Gibt ein Foto als String zurück
  public String getFoto(String robName) {
  	// Roboterkoordinaten und Blickrichtung ermittel
  	int x = -1;
  	int y = -1;
	int yS = 0; int xS=0;
	int view = 0;


  	// aktuelle Position ermitteln
  	for (int i = 0; i < robots.size(); i++) {
        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
        if (neuerRobot.getName().equals(robName)) {
          // aktuelle Position ermitteln zum setzen des Icons
          x = neuerRobot.getX(); y = neuerRobot.getY();
          view = neuerRobot.getView();
        }
    // Sensorfeld ermitteln
    }

      	switch (view) {
        case 1 :  //NORTH
          yS = y - 1;
          xS = x;
          break;
        case 2 :  // NORTHEAST
          yS = y - 1;
          xS = x + 1;
          break;
        case 3 :  //EAST
          xS = x + 1;
          yS = y;
          break;
        case 4 :  // SOUTHEAST
          yS = y + 1;
          xS = x + 1;
          break;
        case 5 : // SOUTH
          yS = y + 1;
          xS = x;
          break;
        case 6 :  // SOUTHWEST
          yS = y + 1;
          xS = x - 1;
          break;
        case 7 :  //WEST
          xS = x - 1;
          yS = y;
          break;
        case 8 :  // NORTHWEST
          yS = y - 1;
          xS = x - 1;
          break;

        default:
          System.out.println("Operand nicht gefunden");
      }
    if (movePossible(xS,yS) ) {



  	// Bild in String codieren
  	try {
  		System.out.println("Koordinaten des Sensorfelds: " + xS +"  " + " yS" );
	  	byte buffer[] = new byte[1000000];
	    FileInputStream in  = new FileInputStream(new File(objektArray[xS][yS].getImageLink()) );
	    int len = in.read( buffer , 0 , 1000000);  // Der Buffer sollte reichen

	    //jpeg wird base64 kodiert und der String ausgegeben
	    return Base64.encodeBytes(buffer, Base64.GZIP);
	}
	catch (Exception e) { return null; }

  	}
  	else { return null; }
}

  // Gibt ein Foto als String zurück
  public String getIR(String robName) {
  	// Roboterkoordinaten und Blickrichtung ermittel
  	int x = -1;
  	int y = -1;
	int yS = 0; int xS=0;
	int view = 0;


  	// aktuelle Position ermitteln
  	for (int i = 0; i < robots.size(); i++) {
        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
        if (neuerRobot.getName().equals(robName)) {
          // aktuelle Position ermitteln zum setzen des Icons
          x = neuerRobot.getX(); y = neuerRobot.getY();
          view = neuerRobot.getView();
        }
    // Sensorfeld ermitteln
    }

      	switch (view) {
        case 1 :  //NORTH
          yS = y - 1;
          xS = x;
          break;
        case 2 :  // NORTHEAST
          yS = y - 1;
          xS = x + 1;
          break;
        case 3 :  //EAST
          xS = x + 1;
          yS = y;
          break;
        case 4 :  // SOUTHEAST
          yS = y + 1;
          xS = x + 1;
          break;
        case 5 : // SOUTH
          yS = y + 1;
          xS = x;
          break;
        case 6 :  // SOUTHWEST
          yS = y + 1;
          xS = x - 1;
          break;
        case 7 :  //WEST
          xS = x - 1;
          yS = y;
          break;
        case 8 :  // NORTHWEST
          yS = y - 1;
          xS = x - 1;
          break;

        default:
          System.out.println("Operand nicht gefunden");
      }
    if (movePossible(xS,yS) ) {



  	// Bild in String codieren
  	try {

  		String s = objektArray[xS][yS].getIRPath();
  		String path;
  		// hier gibts nr ein IR-Bild
  		if ( (objektArray[xS][yS].getFeldTyp().equals("Boden")) && (!(objektArray[xS][yS].getMine())) ) {
  			path = "Bilder/Grasland/th_1_IR.jpg";
  		}
  		else {
  			// Sonst
  			path = s.substring(0, s.length()-4) + "_IR.jpg";
  			System.out.println("Pfad IR: " + path);
  		}

	  	byte buffer[] = new byte[1000000];
	    FileInputStream in  = new FileInputStream(new File(path) );
	    int len = in.read( buffer , 0 , 1000000);  // Der Buffer sollte reichen

	    //jpeg wird base64 kodiert und der String ausgegeben
	    return Base64.encodeBytes(buffer, Base64.GZIP);
	}
	catch (Exception e) { return null; }

  	}
  	else { return null; }
}




  // Karte wird nachbearbeitet
  // Muss vorher geladen werden
  private void karteNachbearbeiten() {
	try {
		manuelleOptionen( anzahlX,anzahlY, false);
	}
	catch (Exception e) { System.out.println(e.toString() ); }

  }

  public String getHoehe(String robName) {
  	int x = -1;
  	int y = -1;



  	// aktuelle Position ermitteln
  	for (int i = 0; i < robots.size(); i++) {
        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
        if (neuerRobot.getName().equals(robName)) {
          // aktuelle Position ermitteln zum setzen des Icons
          x = neuerRobot.getX(); y = neuerRobot.getY();
        }
    }
    return "" + objektArray[x][y].getHoehenstufe();

  }


  public String metall(String robName) {
  	int x = -1;
  	int y = -1;
	int yS = 0; int xS=0;
	int view = 0;


  	// aktuelle Position ermitteln
  	for (int i = 0; i < robots.size(); i++) {
        FieldRobotAttributes neuerRobot = (FieldRobotAttributes) robots.elementAt(i);
        if (neuerRobot.getName().equals(robName)) {
          // aktuelle Position ermitteln zum setzen des Icons
          x = neuerRobot.getX(); y = neuerRobot.getY();
          view = neuerRobot.getView();
        }
    }

      	switch (view) {
        case 1 :  //NORTH
          yS = y - 1;
          xS = x;
          break;
        case 2 :  // NORTHEAST
          yS = y - 1;
          xS = x + 1;
          break;
        case 3 :  //EAST
          xS = x + 1;
          yS = y;
          break;
        case 4 :  // SOUTHEAST
          yS = y + 1;
          xS = x + 1;
          break;
        case 5 : // SOUTH
          yS = y + 1;
          xS = x;
          break;
        case 6 :  // SOUTHWEST
          yS = y + 1;
          xS = x - 1;
          break;
        case 7 :  //WEST
          xS = x - 1;
          yS = y;
          break;
        case 8 :  // NORTHWEST
          yS = y - 1;
          xS = x - 1;
          break;

        default:
          System.out.println("Operand nicht gefunden");
      }
    if (movePossible(xS,yS) ) {

    	return "" + objektArray[xS][yS].getMetallwert();
	}
	else return "false";

  }



}